@bilalimamoglu/sift 0.2.2 → 0.2.3

package/dist/index.js

@@ -53,6 +53,29 @@ 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";
 
@@ -130,7 +153,7 @@ var OpenAIProvider = class {
       if (!text) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.input_tokens,
@@ -139,13 +162,14 @@ var OpenAIProvider = class {
         } : void 0,
         raw: data
       };
+      clearTimeout(timeout);
+      return result;
     } catch (error) {
+      clearTimeout(timeout);
       if (error.name === "AbortError") {
         throw new Error("Provider request timed out");
       }
       throw error;
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
@@ -227,7 +251,7 @@ var OpenAICompatibleProvider = class {
       if (!text.trim()) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.prompt_tokens,
@@ -236,13 +260,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);
     }
   }
 };
@@ -447,6 +472,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:",
@@ -454,6 +492,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}`,
@@ -566,6 +605,410 @@ function inferPackage(line) {
 function inferRemediation(pkg) {
   return `Upgrade ${pkg} to a patched version.`;
 }
+function getCount(input, label) {
+  const matches = [...input.matchAll(new RegExp(`(\\d+)\\s+${label}`, "gi"))];
+  const lastMatch = matches.at(-1);
+  return lastMatch ? Number(lastMatch[1]) : 0;
+}
+function 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)) {
@@ -636,7 +1079,7 @@ function infraRiskHeuristic(input) {
   }
   return null;
 }
-function applyHeuristicPolicy(policyName, input) {
+function applyHeuristicPolicy(policyName, input, detail) {
   if (!policyName) {
     return null;
   }
@@ -646,6 +1089,9 @@ function applyHeuristicPolicy(policyName, input) {
   if (policyName === "infra-risk") {
     return infraRiskHeuristic(input);
   }
+  if (policyName === "test-status") {
+    return testStatusHeuristic(input, detail);
+  }
   return null;
 }
 
@@ -775,6 +1221,7 @@ function buildDryRunOutput(args) {
       },
       question: args.request.question,
       format: args.request.format,
+      detail: args.request.detail ?? null,
       responseMode: args.responseMode,
       policy: args.request.policyName ?? null,
       heuristicOutput: args.heuristicOutput ?? null,
@@ -794,35 +1241,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(
+        `${pc.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);
@@ -830,6 +1284,7 @@ async function runSift(request) {
     question: request.question,
     format: request.format,
     input: prepared.truncated,
+    detail: request.detail,
     policyName: request.policyName,
     outputContract: request.outputContract
   });
@@ -842,7 +1297,8 @@ async function runSift(request) {
   }
   const heuristicOutput = applyHeuristicPolicy(
     request.policyName,
-    prepared.truncated
+    prepared.truncated,
+    request.detail
   );
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
@@ -859,7 +1315,11 @@ async function runSift(request) {
         heuristicOutput
       });
     }
-    return heuristicOutput;
+    return withInsufficientHint({
+      output: heuristicOutput,
+      request,
+      prepared
+    });
   }
   if (request.dryRun) {
     return buildDryRunOutput({
@@ -885,15 +1345,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
     });
   }
 }
@@ -1003,7 +1471,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), {
@@ -1031,7 +1498,6 @@ async function runExec(request) {
   child.stderr.on("data", handleChunk);
   await new Promise((resolve, reject) => {
     child.on("error", (error) => {
-      childSpawnError = error;
       reject(error);
     });
     child.on("close", (status, signal) => {
@@ -1045,9 +1511,6 @@ 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) {
@@ -1057,6 +1520,12 @@ async function runExec(request) {
     );
   }
   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,
@@ -1073,10 +1542,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({
@@ -1386,6 +1863,12 @@ function resolveConfig(options = {}) {
   return siftConfigSchema.parse(merged);
 }
 export {
+  BoundedCapture,
+  buildCommandPreview,
+  getExecSuccessShortcut,
+  looksInteractivePrompt,
+  mergeDefined,
+  normalizeChildExitCode,
   resolveConfig,
   runExec,
   runSift