@linghun/tui 0.1.0 → 0.1.2

package/dist/chunk-4UER2AKI.js

@@ -0,0 +1,636 @@
+// src/headless-bench-runtime.ts
+import { spawn } from "child_process";
+import { constants } from "fs";
+import { access, mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+var DEFAULT_TEST_TIMEOUT_MS = 6e5;
+var DEFAULT_MAX_REPAIR_ATTEMPTS = 1;
+var DEFAULT_ENVIRONMENT_SETUP_RETRIES = 1;
+var MAX_REPAIR_ATTEMPTS = 2;
+var MAX_ENVIRONMENT_SETUP_RETRIES = 3;
+var OUTPUT_LIMIT = 24e3;
+var SUMMARY_LIMIT = 4e3;
+async function resolveHeadlessBenchConfig(input) {
+  const env = input.env ?? process.env;
+  const promptLooksLikeTerminalBench = /Terminal-Bench task container/iu.test(input.prompt);
+  const defaultTestCommand = await detectOfficialTestCommand(input.projectPath, env);
+  const envEnabled = parseBoolean(env.LINGHUN_HEADLESS_BENCH ?? env.LINGHUN_HEADLESS_VERIFY);
+  const enabled = input.options?.enabled ?? envEnabled ?? (promptLooksLikeTerminalBench && Boolean(defaultTestCommand));
+  const optionTestTimeoutMs = input.options?.testTimeoutMs;
+  const testTimeoutMs = clampPositiveInteger(
+    optionTestTimeoutMs ?? parsePositiveInteger(env.LINGHUN_HEADLESS_TEST_TIMEOUT_MS),
+    DEFAULT_TEST_TIMEOUT_MS,
+    optionTestTimeoutMs === void 0 ? 3e4 : 1,
+    18e5
+  );
+  const maxRepairAttempts = clampPositiveInteger(
+    input.options?.maxRepairAttempts ?? parsePositiveInteger(env.LINGHUN_HEADLESS_MAX_REPAIRS),
+    DEFAULT_MAX_REPAIR_ATTEMPTS,
+    0,
+    MAX_REPAIR_ATTEMPTS
+  );
+  const environmentSetupRetries = clampPositiveInteger(
+    input.options?.environmentSetupRetries ?? parsePositiveInteger(env.LINGHUN_HEADLESS_ENV_SETUP_RETRIES),
+    DEFAULT_ENVIRONMENT_SETUP_RETRIES,
+    0,
+    MAX_ENVIRONMENT_SETUP_RETRIES
+  );
+  const configuredArtifacts = splitList(env.LINGHUN_HEADLESS_REQUIRED_ARTIFACTS);
+  const requiredArtifacts = uniqueStrings([
+    ...input.options?.requiredArtifacts ?? [],
+    ...configuredArtifacts,
+    ...detectRequiredArtifacts(input.prompt)
+  ]);
+  const testCommand = input.options?.testCommand ?? env.LINGHUN_HEADLESS_TEST_COMMAND ?? defaultTestCommand;
+  const profile = await detectHeadlessBenchTaskProfile({
+    prompt: input.prompt,
+    projectPath: input.projectPath,
+    requiredArtifacts,
+    testCommand
+  });
+  return {
+    enabled,
+    profile,
+    ...testCommand ? { testCommand } : {},
+    testTimeoutMs,
+    maxRepairAttempts,
+    requiredArtifacts,
+    preflight: input.options?.preflight ?? parseBoolean(env.LINGHUN_HEADLESS_PREFLIGHT) ?? true,
+    environmentSetupRetries
+  };
+}
+async function runHeadlessEnvironmentPreflight(projectPath) {
+  const checkedTools = ["rg", "git", "grep", "find", "sed", "awk", "python3", "python", "node", "cmake", "g++"];
+  const missingTools = [];
+  for (const tool of checkedTools) {
+    if (!await isToolAvailable(tool, projectPath)) {
+      missingTools.push(tool);
+    }
+  }
+  const fallbackNote = missingTools.includes("rg") ? "rg missing; use grep/find fallback. Do not treat missing rg as task failure." : "rg available.";
+  return {
+    checkedTools,
+    missingTools,
+    summary: `tools checked: ${checkedTools.length}; missing: ${missingTools.join(", ") || "none"}; ${fallbackNote}`
+  };
+}
+function createHeadlessBenchInitialPrompt(input) {
+  if (!input.config.enabled) return input.originalPrompt;
+  const required = input.config.requiredArtifacts.length ? `Required artifacts detected: ${input.config.requiredArtifacts.join(", ")}. Verify they exist and are readable before final.` : "No explicit output artifact path was detected; still verify observable task completion.";
+  const test = input.config.testCommand ? `Official test command available: ${input.config.testCommand}. Prefer it over ad-hoc smoke tests before final.` : "No official test command was detected; use the strongest task-local verification available.";
+  const preflight = input.preflight ? `Environment preflight: ${input.preflight.summary}` : "";
+  return [
+    input.originalPrompt,
+    "",
+    "[Linghun headless bench guard]",
+    test,
+    required,
+    preflight,
+    formatInitialProfileStrategy(input.config.profile),
+    "If rg is unavailable, use grep/find/sed/awk fallbacks instead of failing the task.",
+    "Do not claim completion from a self-written smoke test when an official test entrypoint is available."
+  ].filter(Boolean).join("\n");
+}
+async function validateHeadlessBenchCompletion(input) {
+  const artifactResult = await validateRequiredArtifacts(input.projectPath, input.config.requiredArtifacts);
+  if (!artifactResult.ok) {
+    return {
+      ok: false,
+      failure: {
+        category: "missing_artifact",
+        summary: `Missing required artifact(s): ${artifactResult.missing.join(", ")}`,
+        missingArtifacts: artifactResult.missing
+      }
+    };
+  }
+  if (!input.config.testCommand) {
+    return {
+      ok: true,
+      testRan: false,
+      summary: input.config.requiredArtifacts.length ? "required artifacts exist; no official test command detected" : "no official test command or explicit artifact requirement detected"
+    };
+  }
+  let result;
+  let setupRetry = 0;
+  while (setupRetry <= input.config.environmentSetupRetries) {
+    result = await runOfficialTestCommand({
+      projectPath: input.projectPath,
+      command: input.config.testCommand,
+      timeoutMs: input.config.testTimeoutMs
+    });
+    const setupFailure = classifyEnvironmentSetupFailure(result.output);
+    if (result.exitCode === 0 || result.outcome !== "completed" || !setupFailure.retryable || setupRetry >= input.config.environmentSetupRetries) {
+      break;
+    }
+    setupRetry += 1;
+    await sleep(Math.min(500 * 2 ** (setupRetry - 1), 2e3));
+  }
+  if (!result) {
+    throw new Error("headless validation did not run");
+  }
+  if (result.exitCode === 0 && result.outcome === "completed") {
+    return {
+      ok: true,
+      testRan: true,
+      summary: `official test passed: ${input.config.testCommand}`,
+      logPath: result.logPath
+    };
+  }
+  const category = classifyHeadlessFailure({
+    output: result.output,
+    outcome: result.outcome,
+    exitCode: result.exitCode
+  });
+  return {
+    ok: false,
+    failure: {
+      category,
+      command: input.config.testCommand,
+      exitCode: result.exitCode,
+      logPath: result.logPath,
+      summary: summarizeFailureOutput(result.output, category)
+    }
+  };
+}
+async function collectHeadlessArtifactChecklist(input) {
+  const requiredArtifacts = [];
+  for (const artifact of input.config.requiredArtifacts) {
+    const target = artifact.startsWith("/") ? artifact : resolve(input.projectPath, artifact);
+    requiredArtifacts.push({ path: artifact, present: await canRead(target) });
+  }
+  const failedValidation = input.lastValidation && !input.lastValidation.ok ? input.lastValidation.failure : void 0;
+  const gitAvailable = await isToolAvailable("git", input.projectPath).catch(() => "unknown");
+  const verificationRan = input.lastValidation?.ok === true && input.lastValidation.testRan || Boolean(failedValidation?.command);
+  const lastVerificationExitCode = failedValidation?.exitCode;
+  const summary = [
+    `artifacts=${requiredArtifacts.length}`,
+    `artifactsPresent=${requiredArtifacts.filter((item) => item.present).length}/${requiredArtifacts.length}`,
+    `changedFiles=${input.changedFiles.length}`,
+    `verificationRan=${verificationRan ? "yes" : "no"}`,
+    `lastVerificationExitCode=${lastVerificationExitCode ?? "none"}`,
+    `git=${gitAvailable}`
+  ].join("; ");
+  return {
+    requiredArtifacts,
+    changedFiles: [...input.changedFiles],
+    verificationRan,
+    ...lastVerificationExitCode === void 0 ? {} : { lastVerificationExitCode },
+    gitAvailable,
+    summary
+  };
+}
+function classifyEnvironmentSetupFailure(output) {
+  const text = output.toLowerCase();
+  if (!/docker|containerd|image|pull|registry|hub\.docker|manifest|unauthorized/u.test(text)) {
+    return { category: "none", retryable: false, reason: "no environment setup signature" };
+  }
+  if (/unexpected eof|connection reset|connection refused|tls handshake timeout|i\/o timeout|net\/http|temporary failure|temporary name resolution|dial tcp|context deadline exceeded|service unavailable|gateway timeout|too many requests|toomanyrequests|rate limit/u.test(
+    text
+  )) {
+    return {
+      category: "network_pull_error",
+      retryable: true,
+      reason: "transient docker pull or registry network failure"
+    };
+  }
+  if (/no space left|disk quota|cannot allocate memory|out of memory|oom/u.test(text)) {
+    return {
+      category: "environment_error",
+      retryable: false,
+      reason: "local environment resource failure"
+    };
+  }
+  if (/manifest unknown|not found|pull access denied|unauthorized|authentication required|repository does not exist/u.test(text)) {
+    return {
+      category: "environment_error",
+      retryable: false,
+      reason: "non-retryable docker image or registry access failure"
+    };
+  }
+  return { category: "environment_error", retryable: false, reason: "environment setup failure" };
+}
+function createHeadlessBenchRepairPrompt(input) {
+  const artifactLine = input.failure.missingArtifacts?.length ? `Missing artifacts: ${input.failure.missingArtifacts.join(", ")}` : "";
+  const logLine = input.failure.logPath ? `Full failure log: ${input.failure.logPath}` : "";
+  return [
+    `Headless verification failed (${input.failure.category}) on repair attempt ${input.attempt}/${input.maxAttempts}.`,
+    "Continue from the current workspace. Do not restart from scratch unless necessary.",
+    "Use the official test failure and current files to make the smallest fix, then rerun the official test or artifact check.",
+    formatRepairProfileStrategy(input.failure.category, input.profile ?? "generic"),
+    input.preflight?.missingTools.includes("rg") ? "rg is missing in this environment; use grep/find/sed/awk fallbacks." : "",
+    artifactLine,
+    logLine,
+    "",
+    "Failure summary:",
+    input.failure.summary,
+    "",
+    "Original task:",
+    input.originalPrompt
+  ].filter(Boolean).join("\n");
+}
+async function detectHeadlessBenchTaskProfile(input) {
+  const files = await listProjectFiles(input.projectPath, 220);
+  const haystack = `${input.prompt}
+${input.testCommand ?? ""}
+${files.join("\n")}`.toLowerCase();
+  const requiredArtifacts = input.requiredArtifacts ?? detectRequiredArtifacts(input.prompt);
+  if (/qemu|systemd|daemon|server|service|\bport\b|localhost|healthcheck|http server|socket/u.test(haystack)) {
+    return "qemu_or_service";
+  }
+  if (/ctf|crypto|exploit|vulnerab|network|packet|pcap|tls|ssh|jwt|xss|sql injection/u.test(haystack)) {
+    return "security_or_network";
+  }
+  if (/model|train|dataset|csv|parquet|numpy|pandas|sklearn|torch|tensorflow|notebook|\.ipynb/u.test(haystack)) {
+    return "ml_or_data";
+  }
+  if (requiredArtifacts.length > 0 || /binary|artifact|out\.txt|hexdump|strings|elf|file command|ldd|\.bin|\.so|\.exe/u.test(haystack)) {
+    return "binary_or_artifact";
+  }
+  if (/cmakelists\.txt|\.hpp|\.hxx|\.cc|\.cpp|g\+\+|c\+\+|catch2|gtest|polyglot_cpp/u.test(haystack)) {
+    return "polyglot_cpp";
+  }
+  if (/polyglot|exercism|canonical-data|\.go|\.rs|\.java|\.rb|\.js/u.test(haystack)) {
+    return "polyglot_simple";
+  }
+  if (/django|flask|fastapi|pyproject\.toml|setup\.py|tox\.ini|pytest|requirements\.txt/u.test(haystack)) {
+    const pythonFiles = files.filter((file) => file.endsWith(".py")).length;
+    return pythonFiles > 25 || /large|monorepo|package|src\//u.test(haystack) ? "large_python_project" : "swe_python";
+  }
+  return "generic";
+}
+async function detectEngineeringTaskProfile(input) {
+  if (!looksLikeEngineeringProfilePrompt(input.prompt)) return "generic";
+  return detectHeadlessBenchTaskProfile(input);
+}
+function looksLikeEngineeringProfilePrompt(prompt) {
+  return /(?:fix|implement|debug|test|build|compile|artifact|binary|service|server|port|pytest|cmake|c\+\+|python|修|改|实现|调试|测试|构建|编译|产物|服务|端口|智能体|工作流|验证)/iu.test(
+    prompt
+  );
+}
+function classifyHeadlessFailure(input) {
+  const text = input.output.toLowerCase();
+  if (input.outcome === "timeout" || /timed out|timeout after|test command timed out/u.test(text)) {
+    return "test_timeout";
+  }
+  const setupFailure = classifyEnvironmentSetupFailure(input.output);
+  if (setupFailure.category !== "none") {
+    return setupFailure.category;
+  }
+  if (/rate limit|provider|api key|upstream|stream interrupted|connection reset|econnreset|fetch failed/u.test(text)) {
+    return "provider_error";
+  }
+  if (/no space left|cannot allocate memory|out of memory|oom|resource temporarily unavailable/u.test(text)) {
+    return "resource_exhausted";
+  }
+  if (/cmake|g\+\+|undefined reference|compile error|build failed|make: \*\*\*/u.test(text)) {
+    return "model_patch_failed";
+  }
+  if (/command not found|not found:|no such file or directory/u.test(text) && /\brg\b|cmake|g\+\+|python|node/u.test(text)) {
+    return "environment_missing_tool";
+  }
+  if (/no short test summary|error parsing results|harness|post-test|parse/u.test(text)) {
+    return "parse_or_harness_error";
+  }
+  if (/agent timed out|agent_timeout/u.test(text)) {
+    return "agent_timeout";
+  }
+  if (/unknown_agent_error|uncaught|unhandled|internal error/u.test(text)) {
+    return "unknown_agent_error";
+  }
+  return "model_patch_failed";
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function formatInitialProfileStrategy(profile) {
+  switch (profile) {
+    case "polyglot_cpp":
+      return "Profile polyglot_cpp: read headers and official tests first; match signatures exactly; prefer official CMake/tests over ad-hoc g++ smoke.";
+    case "polyglot_simple":
+      return "Profile polyglot_simple: read the canonical tests and target API first; run focused tests before the final official test.";
+    case "swe_python":
+    case "large_python_project":
+      return "Profile python_swe: read relevant tests and target modules first; use focused pytest/tests before any expensive full run; avoid unrelated architecture edits.";
+    case "binary_or_artifact":
+      return "Profile binary_or_artifact: identify file/strings/hexdump/ldd/run mode first; verify required artifacts exist and are non-empty before final.";
+    case "qemu_or_service":
+    case "security_or_network":
+      return "Profile service_security: confirm service, ports, logs, and health checks; wrap long commands with timeouts and clean background processes.";
+    case "ml_or_data":
+      return "Profile ml_or_data: inspect data size and script parameters first; prefer small-sample or focused validation over unbounded training.";
+    case "generic":
+      return "Profile generic: read task-local tests and changed files first; use focused verification before final official validation.";
+  }
+}
+function formatEngineeringProfileStrategyHint(profile) {
+  switch (profile) {
+    case "polyglot_cpp":
+      return "read headers/tests first, align signatures exactly, then verify with the project test entrypoint";
+    case "polyglot_simple":
+      return "read canonical tests and target API first, then run focused verification before final";
+    case "swe_python":
+    case "large_python_project":
+      return "read relevant tests and target modules first, prefer focused tests, and do not imply full-suite pass from focused evidence";
+    case "binary_or_artifact":
+      return "identify artifact expectations early and verify required files exist, are readable, and are non-empty before final";
+    case "qemu_or_service":
+    case "security_or_network":
+      return "verify service, port, logs, or health checks before claiming runtime success; avoid leaving background processes";
+    case "ml_or_data":
+      return "inspect data size and script parameters first, use bounded sample validation before expensive runs";
+    case "generic":
+      return "read task-local sources/tests first and use focused verification before final claims";
+  }
+}
+function formatEngineeringFailureBoundaryHint(input) {
+  if (input.failureCategory === "missing_artifact") {
+    return "final must be downgraded until the required artifact exists and is readable/non-empty";
+  }
+  if (input.failureCategory === "test_timeout") {
+    return "final must state timeout or partial verification; do not present focused checks as full pass";
+  }
+  if (input.failureCategory === "provider_error") {
+    return "final must state provider interruption if completion relies on interrupted model output";
+  }
+  if (input.profile === "binary_or_artifact") {
+    return "final should include artifact existence/non-empty verification status";
+  }
+  if (input.profile === "swe_python" || input.profile === "large_python_project") {
+    return "final should distinguish focused tests from full test-suite verification";
+  }
+  if (input.profile === "qemu_or_service" || input.profile === "security_or_network") {
+    return "final should state whether service/port/log/health checks were actually verified";
+  }
+  return void 0;
+}
+function formatRepairProfileStrategy(category, profile) {
+  if (category === "missing_artifact") {
+    return "Repair route: generate or write the required artifact now, then verify it exists, is readable, and is non-empty.";
+  }
+  if (category === "test_timeout") {
+    return "Repair route: narrow validation to focused tests or logs first; avoid repeatedly launching full expensive runs.";
+  }
+  if (category === "provider_error") {
+    return "Repair route: continue from existing files and evidence; do not redo unrelated exploration.";
+  }
+  if (category === "model_patch_failed" && profile === "polyglot_cpp") {
+    return "Repair route: align header/test signatures, types, missing symbols, and CMake linkage before changing broader logic.";
+  }
+  if (category === "model_patch_failed") {
+    return "Repair route: fix the concrete compile/assertion failure with the smallest patch, then rerun focused verification.";
+  }
+  return "";
+}
+async function detectOfficialTestCommand(projectPath, env) {
+  if (env.LINGHUN_HEADLESS_TEST_COMMAND) return env.LINGHUN_HEADLESS_TEST_COMMAND;
+  const candidates = [
+    "/tests/run-tests.sh",
+    join(projectPath, "tests", "run-tests.sh"),
+    join(projectPath, "run-tests.sh")
+  ];
+  for (const candidate of candidates) {
+    if (await canRead(candidate)) {
+      return candidate.endsWith(".sh") ? `bash ${shellQuote(candidate)}` : shellQuote(candidate);
+    }
+  }
+  return void 0;
+}
+async function listProjectFiles(projectPath, limit) {
+  const results = [];
+  const ignored = /* @__PURE__ */ new Set([".git", "node_modules", ".linghun", "__pycache__", ".pytest_cache", "dist", "build"]);
+  async function walk(dir, prefix) {
+    if (results.length >= limit) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (results.length >= limit || ignored.has(entry.name)) continue;
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath, relative);
+      } else if (entry.isFile()) {
+        results.push(relative);
+      }
+    }
+  }
+  await walk(projectPath, "");
+  return results;
+}
+function detectEngineeringArtifactTargets(prompt) {
+  const artifacts = [];
+  const absolutePathPattern = /(?:\b(?:write|save|print|output|store|create|generate|return|place|put)\b|写入|保存|输出|生成|创建|放到|放入|返回)[\s\S]{0,120}?[`"']?(\/[A-Za-z0-9._/-]+\.[A-Za-z0-9._-]+)[`"']?/giu;
+  for (const match of prompt.matchAll(absolutePathPattern)) {
+    artifacts.push(match[1]);
+  }
+  const namedFilePattern = /(?:\b(?:file called|file named|called|named|to a file|write .*? to)\b|文件名为|文件叫|写到文件|输出到文件)\s+[`"']?([A-Za-z0-9._/-]+\.[A-Za-z0-9._-]+)[`"']?/giu;
+  for (const match of prompt.matchAll(namedFilePattern)) {
+    artifacts.push(match[1]);
+  }
+  return uniqueStrings(
+    artifacts.map(normalizeArtifactPath).filter((artifact) => !artifact.includes("*") && !artifact.endsWith(".sh"))
+  );
+}
+function detectRequiredArtifacts(prompt) {
+  return detectEngineeringArtifactTargets(prompt);
+}
+function normalizeArtifactPath(value) {
+  return value.replace(/[),.;:!?]+$/u, "");
+}
+async function validateRequiredArtifacts(projectPath, artifacts) {
+  const missing = [];
+  for (const artifact of artifacts) {
+    const target = artifact.startsWith("/") ? artifact : resolve(projectPath, artifact);
+    try {
+      await access(target, constants.R_OK);
+      const content = await readFile(target, "utf8").catch(() => "");
+      if (content.length === 0) {
+        missing.push(`${artifact} (empty or unreadable text)`);
+      }
+    } catch {
+      missing.push(artifact);
+    }
+  }
+  return missing.length ? { ok: false, missing } : { ok: true };
+}
+async function runOfficialTestCommand(input) {
+  const result = await runShellCommand(input.command, input.projectPath, input.timeoutMs);
+  const postTestLog = result.exitCode === 0 ? "" : await readPostTestFailureLog(input.projectPath);
+  const output = postTestLog ? `${result.output}
+
+[post-test/tests.log]
+${postTestLog}` : result.output;
+  const logPath = await writeHeadlessLog(input.projectPath, "official-test.log", output);
+  return { ...result, output, logPath };
+}
+function runShellCommand(command, cwd, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const detached = process.platform !== "win32";
+    const child = spawn(command, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      detached,
+      env: createSanitizedChildEnv(process.env)
+    });
+    let output = "";
+    let settled = false;
+    const append = (chunk) => {
+      output += chunk.toString();
+      if (output.length > OUTPUT_LIMIT) {
+        output = output.slice(output.length - OUTPUT_LIMIT);
+      }
+    };
+    const finish = (exitCode, outcome = "completed") => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise({ exitCode, output, outcome });
+    };
+    const timer = setTimeout(() => {
+      append(`
+Command timed out after ${timeoutMs}ms.`);
+      killShellProcess(child.pid);
+      finish(1, "timeout");
+    }, timeoutMs);
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.on("error", (error) => {
+      append(`
+Command failed to start: ${error.message}`);
+      finish(1);
+    });
+    child.on("close", (code) => finish(code ?? 1));
+  });
+}
+function createSanitizedChildEnv(env) {
+  const next = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (isSecretEnvKey(key)) continue;
+    next[key] = value;
+  }
+  return next;
+}
+function isSecretEnvKey(key) {
+  return /(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|AUTHORIZATION|BEARER|CREDENTIAL)/iu.test(key);
+}
+function killShellProcess(pid) {
+  if (!pid) return;
+  try {
+    if (process.platform === "win32") {
+      spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+        stdio: "ignore",
+        windowsHide: true
+      }).unref();
+      process.kill(pid);
+    } else {
+      process.kill(-pid, "SIGTERM");
+      setTimeout(() => {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+        }
+      }, 1e3).unref();
+    }
+  } catch {
+    try {
+      process.kill(pid);
+    } catch {
+    }
+  }
+}
+async function isToolAvailable(tool, cwd) {
+  const command = process.platform === "win32" ? `where ${cmdQuote(tool)} >nul 2>nul` : `command -v ${shellQuote(tool)} >/dev/null 2>&1`;
+  const result = await runShellCommand(command, cwd, 5e3);
+  return result.exitCode === 0;
+}
+async function writeHeadlessLog(projectPath, name, content) {
+  const dir = join(projectPath, ".linghun", "headless");
+  await mkdir(dir, { recursive: true });
+  const target = join(dir, name);
+  await writeFile(target, content, "utf8");
+  return target;
+}
+async function readPostTestFailureLog(projectPath) {
+  const candidates = [
+    join(projectPath, "post-test", "tests.log"),
+    join(projectPath, "post_test", "tests.log"),
+    join(projectPath, "tests.log"),
+    "/post-test/tests.log"
+  ];
+  for (const candidate of candidates) {
+    try {
+      const content = await readFile(candidate, "utf8");
+      return content.length > OUTPUT_LIMIT ? content.slice(content.length - OUTPUT_LIMIT) : content;
+    } catch {
+    }
+  }
+  return "";
+}
+function summarizeFailureOutput(output, category) {
+  const lines = output.split(/\r?\n/u).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+  const interesting = lines.filter(
+    (line) => /error|failed|failure|assert|expected|actual|traceback|exception|undefined reference|no such file|not found|timeout|cmake|g\+\+|make|pytest|test/u.test(
+      line.toLowerCase()
+    )
+  );
+  const selected = (interesting.length ? interesting : lines).slice(-60).join("\n");
+  const summary = selected.length > SUMMARY_LIMIT ? selected.slice(selected.length - SUMMARY_LIMIT) : selected;
+  return `[${category}]
+${summary || "No failure output captured."}`;
+}
+function parseBoolean(value) {
+  if (value === void 0) return void 0;
+  if (/^(1|true|yes|on)$/iu.test(value)) return true;
+  if (/^(0|false|no|off)$/iu.test(value)) return false;
+  return void 0;
+}
+function parsePositiveInteger(value) {
+  if (!value) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function clampPositiveInteger(value, fallback, min, max) {
+  const next = value ?? fallback;
+  return Math.max(min, Math.min(max, next));
+}
+function splitList(value) {
+  return value ? value.split(/[;,]/u).map((item) => item.trim()).filter(Boolean) : [];
+}
+function uniqueStrings(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+async function canRead(path) {
+  try {
+    await access(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:-]+$/u.test(value)) return value;
+  return `'${value.replace(/'/gu, "'\\''")}'`;
+}
+function cmdQuote(value) {
+  return /^[A-Za-z0-9_.+-]+$/u.test(value) ? value : `"${value.replace(/"/gu, '\\"')}"`;
+}
+
+export {
+  resolveHeadlessBenchConfig,
+  runHeadlessEnvironmentPreflight,
+  createHeadlessBenchInitialPrompt,
+  validateHeadlessBenchCompletion,
+  collectHeadlessArtifactChecklist,
+  classifyEnvironmentSetupFailure,
+  createHeadlessBenchRepairPrompt,
+  detectHeadlessBenchTaskProfile,
+  detectEngineeringTaskProfile,
+  classifyHeadlessFailure,
+  formatEngineeringProfileStrategyHint,
+  formatEngineeringFailureBoundaryHint,
+  detectEngineeringArtifactTargets
+};

package/dist/{chunk-WHFDDZHY.js → chunk-5IFNLTOF.js}

@@ -1,17 +1,17 @@
 import {
   createCompactBoundaryBlock
-} from "./chunk-AKPXMCVF.js";
+} from "./chunk-EKYXI6C7.js";
 import {
   createEvidenceRecord,
   rememberEvidence
-} from "./chunk-64MJP6FK.js";
+} from "./chunk-NK4NMYF5.js";
 import {
   applyToolResultBudgetToMessages
 } from "./chunk-O7S3HYE6.js";
 import {
   injectDeepCompactSummary,
   maybeRunDeepCompactBeforeProvider
-} from "./chunk-RMLTVKOY.js";
+} from "./chunk-L4YVE3RG.js";
 import {
   getContextWindowForModel
 } from "./chunk-K4FSYBSY.js";
@@ -28,7 +28,7 @@ import {
   sanitizeDiagnosticText,
   sanitizeDisplayPaths,
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/compact-preflight-runtime.ts
 import "@linghun/providers";

package/dist/{chunk-W3KHJNSH.js → chunk-6CHUZ2NF.js}

@@ -1,12 +1,12 @@
 import {
   isRecord
-} from "./chunk-QLRTQHTR.js";
+} from "./chunk-6JGRNES6.js";
 import {
   stableStringify
 } from "./chunk-4T5DJW54.js";
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/index-result-presenter.ts
 import { readFile, readdir, stat } from "fs/promises";