@bilalimamoglu/sift 0.2.1 → 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";
 
@@ -13,12 +13,17 @@ import YAML from "yaml";
 import os from "os";
 import path from "path";
 var DEFAULT_CONFIG_FILENAME = "sift.config.yaml";
-var DEFAULT_CONFIG_SEARCH_PATHS = [
-  path.resolve(process.cwd(), "sift.config.yaml"),
-  path.resolve(process.cwd(), "sift.config.yml"),
-  path.join(os.homedir(), ".config", "sift", "config.yaml"),
-  path.join(os.homedir(), ".config", "sift", "config.yml")
-];
+function getDefaultGlobalConfigPath() {
+  return path.join(os.homedir(), ".config", "sift", "config.yaml");
+}
+function getDefaultConfigSearchPaths() {
+  return [
+    path.resolve(process.cwd(), "sift.config.yaml"),
+    path.resolve(process.cwd(), "sift.config.yml"),
+    getDefaultGlobalConfigPath(),
+    path.join(os.homedir(), ".config", "sift", "config.yml")
+  ];
+}
 var INSUFFICIENT_SIGNAL_TEXT = "Insufficient signal in the provided input.";
 var GENERIC_JSON_CONTRACT = '{"answer":string,"evidence":string[],"risks":string[]}';
 var CAPTURE_OMITTED_MARKER = "\n...[captured output omitted]...\n";
@@ -32,7 +37,7 @@ function findConfigPath(explicitPath) {
     }
     return resolved;
   }
-  for (const candidate of DEFAULT_CONFIG_SEARCH_PATHS) {
+  for (const candidate of getDefaultConfigSearchPaths()) {
     if (fs.existsSync(candidate)) {
       return candidate;
     }
@@ -339,8 +344,11 @@ function resolveConfig(options = {}) {
 import fs2 from "fs";
 import path3 from "path";
 import YAML2 from "yaml";
-function writeExampleConfig(targetPath) {
-  const resolved = path3.resolve(targetPath ?? DEFAULT_CONFIG_FILENAME);
+function writeExampleConfig(options = {}) {
+  if (options.global && options.targetPath) {
+    throw new Error("Use either --path <path> or --global, not both.");
+  }
+  const resolved = options.global ? getDefaultGlobalConfigPath() : path3.resolve(options.targetPath ?? DEFAULT_CONFIG_FILENAME);
   if (fs2.existsSync(resolved)) {
     throw new Error(`Config file already exists at ${resolved}`);
   }
@@ -349,6 +357,414 @@ function writeExampleConfig(targetPath) {
   fs2.writeFileSync(resolved, yaml, "utf8");
   return resolved;
 }
+function writeConfigFile(options) {
+  const resolved = path3.resolve(options.targetPath);
+  if (!options.overwrite && fs2.existsSync(resolved)) {
+    throw new Error(`Config file already exists at ${resolved}`);
+  }
+  const yaml = YAML2.stringify(options.config);
+  fs2.mkdirSync(path3.dirname(resolved), { recursive: true });
+  fs2.writeFileSync(resolved, yaml, {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    fs2.chmodSync(resolved, 384);
+  } catch {
+  }
+  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 { 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: defaultStdin2,
+        output: defaultStdout,
+        terminal: true
+      });
+    }
+    return rl;
+  }
+  async function select(prompt, options) {
+    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(defaultStdin2.isTTY),
+    stdoutIsTTY: Boolean(defaultStdout.isTTY),
+    ask(prompt) {
+      return getInterface().question(prompt);
+    },
+    select,
+    secret,
+    write(message) {
+      defaultStdout.write(message);
+    },
+    error(message) {
+      defaultStderr.write(message);
+    },
+    close() {
+      rl?.close();
+    }
+  };
+}
+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
+    }
+  };
+}
+function getSetupPresenter(io) {
+  return createPresentation(io.stdoutIsTTY);
+}
+async function promptForProvider(io) {
+  if (io.select) {
+    const choice = await io.select("Select provider for this machine", ["OpenAI"]);
+    if (choice === "OpenAI") {
+      return "openai";
+    }
+  }
+  while (true) {
+    const answer = (await io.ask("Provider [OpenAI]: ")).trim().toLowerCase();
+    if (answer === "" || answer === "openai") {
+      return "openai";
+    }
+    io.error("Only OpenAI is supported in guided setup right now.\n");
+  }
+}
+async function promptForApiKey(io) {
+  while (true) {
+    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;
+    }
+    io.error("API key cannot be empty.\n");
+  }
+}
+async function promptForOverwrite(io, targetPath) {
+  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;
+    }
+    if (answer === "y" || answer === "yes") {
+      return true;
+    }
+    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(
+        "sift config setup is interactive and requires a TTY. Use 'sift config init --global' for a non-interactive template.\n"
+      );
+      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(`${ui.note("Aborted.")}
+`);
+        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 writtenPath = writeConfigFile({
+      targetPath: resolvedPath,
+      config,
+      overwrite: true
+    });
+    writeSetupSuccess(io, writtenPath);
+    const activeConfigPath = findConfigPath();
+    if (activeConfigPath && path4.resolve(activeConfigPath) !== path4.resolve(writtenPath)) {
+      writeOverrideWarning(io, activeConfigPath);
+    }
+    writeNextSteps(io);
+    return 0;
+  } finally {
+    io.close?.();
+  }
+}
 
 // src/commands/config.ts
 var MASKED_SECRET = "***";
@@ -369,10 +785,21 @@ function maskConfigSecrets(value) {
   }
   return output;
 }
-function configInit(targetPath) {
-  const path4 = writeExampleConfig(targetPath);
-  process.stdout.write(`${path4}
+function configInit(targetPath, global = false) {
+  const path5 = writeExampleConfig({
+    targetPath,
+    global
+  });
+  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({
@@ -389,24 +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) {
+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",
-    `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")}
 `);
@@ -427,8 +862,16 @@ function runDoctor(config) {
     );
   }
   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;
@@ -457,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"]);
@@ -506,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.";
@@ -583,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,
@@ -592,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);
     }
   }
 };
@@ -680,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,
@@ -689,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);
     }
   }
 };
@@ -900,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:",
@@ -907,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}`,
@@ -1019,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)) {
@@ -1089,7 +1975,7 @@ function infraRiskHeuristic(input) {
   }
   return null;
 }
-function applyHeuristicPolicy(policyName, input) {
+function applyHeuristicPolicy(policyName, input, detail) {
   if (!policyName) {
     return null;
   }
@@ -1099,6 +1985,9 @@ function applyHeuristicPolicy(policyName, input) {
   if (policyName === "infra-risk") {
     return infraRiskHeuristic(input);
   }
+  if (policyName === "test-status") {
+    return testStatusHeuristic(input, detail);
+  }
   return null;
 }
 
@@ -1228,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,
@@ -1247,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);
@@ -1283,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) {
@@ -1312,7 +2211,11 @@ async function runSift(request) {
         heuristicOutput
       });
     }
-    return heuristicOutput;
+    return withInsufficientHint({
+      output: heuristicOutput,
+      request,
+      prepared
+    });
   }
   if (request.dryRun) {
     return buildDryRunOutput({
@@ -1338,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
     });
   }
 }
@@ -1429,6 +2340,15 @@ function buildCommandPreview(request) {
   }
   return (request.command ?? []).join(" ");
 }
+function getExecSuccessShortcut(args) {
+  if (args.exitCode !== 0) {
+    return null;
+  }
+  if (args.presetName === "typecheck-summary" && args.capturedOutput.trim() === "") {
+    return "No type errors.";
+  }
+  return null;
+}
 async function runExec(request) {
   const hasArgvCommand = Array.isArray(request.command) && request.command.length > 0;
   const hasShellCommand = typeof request.shellCommand === "string";
@@ -1438,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)}
 `
     );
   }
@@ -1447,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), {
@@ -1466,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());
@@ -1475,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) => {
@@ -1489,21 +2407,49 @@ 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) {
-    const output = await runSift({
+    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,
+      capturedOutput
+    });
+    if (execSuccessShortcut && !request.dryRun) {
+      if (request.config.runtime.verbose) {
+        process.stderr.write(
+          `${pc3.dim("sift")} exec_shortcut=${request.presetName}
+`
+        );
+      }
+      process.stdout.write(`${execSuccessShortcut}
+`);
+      return exitCode;
+    }
+    let output = await runSift({
       ...request,
-      stdin: capture.render()
+      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({
@@ -1537,10 +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 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;
@@ -1585,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)) : [];
@@ -1638,160 +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: init | show | validate (show/validate use resolved runtime config)"
-).usage("config <init|show|validate> [options]").example("config init").example("config show").example("config validate --config ./sift.config.yaml").option("--path <path>", "Target config path for init").option("--config <path>", "Path to config file").option("--show-secrets", "Show secret values in config show").action((action, options) => {
-  if (action === "init") {
-    configInit(options.path);
-    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 config = resolveConfig({
-    configPath: options.config,
-    env: process.env
+  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
+    });
   });
-  process.exitCode = runDoctor(config);
-});
-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();
-cli.version(pkg.version);
-async function main() {
-  cli.parse(process.argv, { run: false });
+  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)}
+`
+      },
+      {
+        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);
 });