@poetic-ai/poetic 1.42.0

package/dist/chunk-FHOWVDF5.js

@@ -0,0 +1,1342 @@
+import {
+  isProjectTestPath
+} from "./chunk-UDMS5AD3.js";
+import {
+  describeVerificationCommand
+} from "./chunk-2QLYTVYX.js";
+
+// src/core/project/capabilities.ts
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync
+} from "fs";
+import path from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+
+// src/core/project/iac-runner-commands.ts
+var STATIC_NONPACKAGE_LINT_PREFIXES = [
+  "terraform fmt",
+  "hadolint ",
+  "tflint",
+  "kubeconform",
+  "pwsh -NoProfile -Command Invoke-"
+];
+function isNonPackageStaticLintCommand(command) {
+  const trimmed = command.trimStart();
+  return STATIC_NONPACKAGE_LINT_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+var IAC_STATIC_LINT_PREFIXES = ["terraform fmt", "hadolint ", "tflint", "kubeconform"];
+function isIacStaticCommand(command) {
+  const trimmed = command.trimStart();
+  return IAC_STATIC_LINT_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+function isIacProjectPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const base = normalized.split("/").pop() ?? normalized;
+  return base === "dockerfile" || base.endsWith(".tf") || base.endsWith(".tfvars");
+}
+var POWERSHELL_EXECUTABLES = ["pwsh", "pwsh.exe", "powershell", "powershell.exe"];
+function isPowerShellStaticCommand(command) {
+  const tokens = command.trim().split(/\s+/);
+  const executable = tokens[0];
+  if (executable === void 0 || !POWERSHELL_EXECUTABLES.includes(executable)) {
+    return false;
+  }
+  return tokens.some((token) => token.startsWith("Invoke-"));
+}
+function buildIacLintCommands(detected) {
+  const commands = [];
+  if (detected.dockerfile && detected.hadolintConfig) {
+    commands.push("hadolint Dockerfile");
+  }
+  if (detected.terraform) {
+    commands.push("terraform fmt -check -recursive");
+  }
+  if (detected.terraform && detected.tflintConfig) {
+    commands.push("tflint --recursive");
+  }
+  return commands;
+}
+function buildRunnerCommands(detected, kind) {
+  if (detected.availableTasks === void 0) {
+    return [];
+  }
+  if (!detected.availableTasks.includes(kind)) {
+    return [];
+  }
+  const commands = [];
+  if (detected.just) {
+    commands.push(`just ${kind}`);
+  }
+  if (detected.task) {
+    commands.push(`task ${kind}`);
+  }
+  return commands;
+}
+function buildPowerShellCommands(detected) {
+  const test = [];
+  const lint = [];
+  if (detected.pesterConfig) {
+    test.push("pwsh -NoProfile -Command Invoke-Pester -CI");
+  }
+  return { test, lint };
+}
+
+// src/core/project/capabilities.ts
+var PROJECT_LANGUAGES = [
+  "node",
+  "typescript",
+  "javascript",
+  "c",
+  "cpp",
+  "python",
+  "go",
+  "rust",
+  "java",
+  "dotnet",
+  "swift",
+  "kotlin",
+  "dart",
+  "ruby",
+  "php",
+  "shell",
+  "powershell",
+  "r",
+  "sql",
+  "docs",
+  "unknown"
+];
+function fileExists(root, file) {
+  return existsSync(path.join(root, file));
+}
+function directoryStaysInsideRoot(root, relativeDirectory) {
+  const directoryPath = path.join(root, relativeDirectory);
+  try {
+    const stat = lstatSync(directoryPath);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) return false;
+    const rootRealPath = realpathSync(root);
+    const directoryRealPath = realpathSync(directoryPath);
+    const relativePath = path.relative(rootRealPath, directoryRealPath);
+    return relativePath.length === 0 || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  } catch {
+    return false;
+  }
+}
+var PROJECT_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".poetic",
+  "node_modules",
+  "dist",
+  "build",
+  "target",
+  "vendor",
+  ".venv",
+  "venv",
+  "__pycache__",
+  // Terraform's generated provider/module cache. A checkout containing only
+  // `.terraform/modules/.../*.tf` cache files must NOT be detected as a Terraform
+  // project (that would run irrelevant `terraform fmt` on generated dependency
+  // content). Only first-party `*.tf` outside this cache should count.
+  ".terraform"
+]);
+var IGNORED_ANYWHERE_SEGMENTS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".poetic",
+  "node_modules",
+  ".venv",
+  "venv",
+  "__pycache__",
+  ".terraform"
+]);
+function isIgnoredProjectPath(relativePath, extra) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return false;
+  if (segments.some((segment) => IGNORED_ANYWHERE_SEGMENTS.has(segment))) {
+    return true;
+  }
+  const leading = segments[0];
+  const extraSet = extra ? new Set(extra) : /* @__PURE__ */ new Set();
+  return PROJECT_IGNORED_DIRECTORIES.has(leading) || extraSet.has(leading);
+}
+var FIXTURE_TREE_PARENTS = /* @__PURE__ */ new Set(["tests", "test"]);
+function isIgnoredFixtureOrSentinelPath(relativePath) {
+  const segments = relativePath.replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) return false;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const current = segments[i];
+    const next = segments[i + 1];
+    if (current !== void 0 && next !== void 0 && FIXTURE_TREE_PARENTS.has(current) && next === "fixtures") {
+      return true;
+    }
+  }
+  const last = segments[segments.length - 1] ?? "";
+  const lastLooksLikeFile = last.includes(".") && !last.startsWith(".");
+  const directorySegments = lastLooksLikeFile ? segments.slice(0, -1) : segments;
+  return directorySegments.some((segment) => /sentinel/i.test(segment));
+}
+function isIgnoredLanguageSignalPath(relativePath) {
+  return isIgnoredProjectPath(relativePath) || isIgnoredFixtureOrSentinelPath(relativePath);
+}
+function hasFileMatching(root, predicate) {
+  return collectFilesMatching(root, predicate, 1).length > 0;
+}
+function collectFilesMatching(root, predicate, limit = 50) {
+  const ignoredDirectories = PROJECT_IGNORED_DIRECTORIES;
+  const stack = [""];
+  const matches = [];
+  while (stack.length > 0) {
+    const relativeDirectory = stack.pop() ?? "";
+    const absoluteDirectory = path.join(root, relativeDirectory);
+    let entries;
+    try {
+      entries = readdirSync(absoluteDirectory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && ignoredDirectories.has(entry.name)) continue;
+      const relativePath = path.join(relativeDirectory, entry.name);
+      const absolutePath = path.join(root, relativePath);
+      if (entry.isDirectory()) {
+        if (ignoredDirectories.has(entry.name) || isIgnoredLanguageSignalPath(relativePath)) {
+          continue;
+        }
+        stack.push(relativePath);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        let isFile = entry.isFile();
+        if (!isFile) {
+          try {
+            isFile = statSync(absolutePath).isFile();
+          } catch {
+            isFile = false;
+          }
+        }
+        if (isFile && !isIgnoredLanguageSignalPath(relativePath) && predicate(relativePath, entry.name)) {
+          matches.push(relativePath);
+          if (matches.length >= limit) return matches;
+        }
+      }
+    }
+  }
+  return matches;
+}
+function commandExists(command) {
+  const pathEnv = process.env.PATH ?? "";
+  const pathEntries = pathEnv.split(path.delimiter).filter(Boolean);
+  const extensions = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean) : [""];
+  return pathEntries.some(
+    (entry) => extensions.some((extension) => existsSync(path.join(entry, `${command}${extension}`)))
+  );
+}
+function readJsonFile(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readJsonArrayProperty(filePath, property) {
+  const parsed = readJsonFile(filePath);
+  const value = parsed?.[property];
+  return Array.isArray(value) ? value.filter(
+    (entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry)
+  ) : [];
+}
+function isSafeCommandToken(value) {
+  return /^[A-Za-z0-9_.+-]+$/.test(value) && !value.startsWith("-");
+}
+function cmakeBinaryDirStaysInsideWorktree(binaryDir) {
+  if (typeof binaryDir !== "string" || binaryDir.trim().length === 0) return true;
+  let normalized = binaryDir.trim().replace(/\\/g, "/");
+  const cmakeSourceDirPrefix = "${sourceDir}/";
+  if (normalized.startsWith(cmakeSourceDirPrefix)) {
+    normalized = normalized.slice(cmakeSourceDirPrefix.length);
+  } else if (normalized.includes("$")) {
+    return false;
+  }
+  if (path.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized)) return false;
+  return !normalized.split("/").some((part) => part === "..");
+}
+function presetInheritedNames(preset) {
+  const inherits = preset.inherits;
+  if (typeof inherits === "string") return [inherits.trim()].filter(Boolean);
+  if (Array.isArray(inherits)) {
+    return inherits.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+  }
+  return [];
+}
+function resolveCMakePreset(presets, name, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(name)) return void 0;
+  const preset = presets.get(name);
+  if (!preset) return void 0;
+  seen.add(name);
+  let resolved = {};
+  for (const parentName of presetInheritedNames(preset)) {
+    const parent = resolveCMakePreset(presets, parentName, seen);
+    if (parent) resolved = { ...parent, ...resolved };
+  }
+  return { ...resolved, ...preset };
+}
+function firstSafeCMakePresetName(filePath, property) {
+  const configurePresets = /* @__PURE__ */ new Map();
+  for (const entry of readJsonArrayProperty(filePath, "configurePresets")) {
+    if (typeof entry.name === "string") configurePresets.set(entry.name.trim(), entry);
+  }
+  const candidatePresets = /* @__PURE__ */ new Map();
+  for (const entry of readJsonArrayProperty(filePath, property)) {
+    if (typeof entry.name === "string") candidatePresets.set(entry.name.trim(), entry);
+  }
+  for (const name of candidatePresets.keys()) {
+    if (name.length === 0 || !isSafeCommandToken(name)) continue;
+    const entry = resolveCMakePreset(candidatePresets, name);
+    if (!entry) continue;
+    const configurePresetName = typeof entry.configurePreset === "string" ? entry.configurePreset.trim() : "";
+    const configurePreset = configurePresetName ? resolveCMakePreset(configurePresets, configurePresetName) : void 0;
+    if (!cmakeBinaryDirStaysInsideWorktree(configurePreset?.binaryDir)) continue;
+    return name;
+  }
+  return void 0;
+}
+function readTextFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8");
+    return typeof content === "string" ? content : "";
+  } catch {
+    return "";
+  }
+}
+function readTextFilePrefix(filePath, maxBytes) {
+  try {
+    const content = readFileSync(filePath, "utf8");
+    return typeof content === "string" ? content.slice(0, maxBytes) : "";
+  } catch {
+    return "";
+  }
+}
+function readPackageScripts(root) {
+  const pkg = readJsonFile(path.join(root, "package.json"));
+  const rawScripts = pkg?.scripts;
+  if (!rawScripts || typeof rawScripts !== "object" || Array.isArray(rawScripts)) {
+    return {};
+  }
+  const scripts = {};
+  for (const [key, value] of Object.entries(rawScripts)) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      scripts[key] = value;
+    }
+  }
+  return scripts;
+}
+function readComposerScripts(root) {
+  const composer = readJsonFile(path.join(root, "composer.json"));
+  const rawScripts = composer?.scripts;
+  if (!rawScripts || typeof rawScripts !== "object" || Array.isArray(rawScripts)) {
+    return {};
+  }
+  const scripts = {};
+  for (const [key, value] of Object.entries(rawScripts)) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      scripts[key] = value;
+    } else if (Array.isArray(value) && value.length > 0) {
+      scripts[key] = value.map((entry) => String(entry)).join(" && ");
+    }
+  }
+  return scripts;
+}
+function readVerificationOverrides(root) {
+  const configPath = [
+    path.join(root, ".poetic", "config", "poetic.config.jsonc"),
+    path.join(root, "poetic.config.jsonc")
+  ].find((candidate) => existsSync(candidate));
+  if (!configPath) return {};
+  try {
+    const parsed = parseJsonc(readFileSync(configPath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const verification = parsed.verification;
+    if (!verification || typeof verification !== "object" || Array.isArray(verification)) return {};
+    const out = {};
+    for (const key of [
+      "format",
+      "build",
+      "typecheck",
+      "lint",
+      "test",
+      "audit",
+      "coverage"
+    ]) {
+      const value = verification[key];
+      if (typeof value === "string" && value.trim().length > 0) {
+        out[key] = [value.trim()];
+      } else if (Array.isArray(value)) {
+        out[key] = value.filter(
+          (entry) => typeof entry === "string" && entry.trim().length > 0
+        );
+      }
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function detectPackageManager(root) {
+  const pkg = readJsonFile(path.join(root, "package.json"));
+  const packageManager = pkg?.packageManager;
+  if (typeof packageManager === "string") {
+    const manager = packageManager.split("@")[0];
+    if (manager === "npm" || manager === "pnpm" || manager === "yarn" || manager === "bun") {
+      return manager;
+    }
+  }
+  if (fileExists(root, "pnpm-lock.yaml")) return "pnpm";
+  if (fileExists(root, "yarn.lock")) return "yarn";
+  if (fileExists(root, "bun.lockb") || fileExists(root, "bun.lock")) return "bun";
+  return "npm";
+}
+function buildPackageScriptCommand(root, script) {
+  const manager = detectPackageManager(root);
+  if (manager === "npm") {
+    return script === "test" ? "npm test" : `npm run ${script}`;
+  }
+  if (manager === "yarn") {
+    return script === "test" ? "yarn test" : `yarn run ${script}`;
+  }
+  return `${manager} run ${script}`;
+}
+function packageRunCommand(root, script) {
+  return buildPackageScriptCommand(root, script);
+}
+function hasPackageDependency(root, dependency) {
+  const pkg = readJsonFile(path.join(root, "package.json"));
+  return Boolean(pkg?.dependencies?.[dependency] ?? pkg?.devDependencies?.[dependency]);
+}
+function hasLocalPackageBin(root, executable) {
+  const extension = process.platform === "win32" ? ".cmd" : "";
+  return existsSync(path.join(root, "node_modules", ".bin", `${executable}${extension}`));
+}
+function pythonModuleCommand(module, args = "") {
+  const suffix = args.trim().length > 0 ? ` ${args.trim()}` : "";
+  if (commandExists("python3")) return `python3 -m ${module}${suffix}`;
+  if (commandExists("python")) return `python -m ${module}${suffix}`;
+  if (process.platform === "win32" && commandExists("py")) return `py -m ${module}${suffix}`;
+  return `python3 -m ${module}${suffix}`;
+}
+function hasPythonSrcPackageLayout(root) {
+  if (!directoryStaysInsideRoot(root, "src")) return false;
+  return hasFileMatching(root, (relativePath, basename) => {
+    if (!basename.endsWith(".py")) return false;
+    const normalized = relativePath.replace(/\\/g, "/");
+    return normalized.startsWith("src/");
+  });
+}
+function pythonCommandWithSrcPath(root, command) {
+  if (process.platform === "win32" || !hasPythonSrcPackageLayout(root)) return command;
+  return `env PYTHONPATH=src ${command}`;
+}
+function isPythonUnitTestRelativePath(relativePath, basename) {
+  if (!basename.endsWith(".py")) return false;
+  const normalized = relativePath.replace(/\\/g, "/");
+  return /^tests?\//.test(normalized) || /(?:^|\/)test_[^/]+\.py$/.test(normalized) || /(?:^|\/)[^/]+_test\.py$/.test(normalized);
+}
+function pythonUnittestDiscoveryRoot(root) {
+  for (const dir of ["tests", "test"]) {
+    if (directoryStaysInsideRoot(root, dir) && hasFileMatching(
+      root,
+      (relativePath, basename) => basename.endsWith(".py") && relativePath.replace(/\\/g, "/").split("/")[0] === dir && !isIgnoredFixtureOrSentinelPath(relativePath)
+    )) {
+      return dir;
+    }
+  }
+  if (hasFileMatching(
+    root,
+    (relativePath, basename) => !relativePath.replace(/\\/g, "/").includes("/") && isPythonUnitTestRelativePath(relativePath, basename)
+  )) {
+    return ".";
+  }
+  return null;
+}
+function pythonUnittestCommand(root) {
+  const start = pythonUnittestDiscoveryRoot(root);
+  if (start === null) return null;
+  return pythonCommandWithSrcPath(root, pythonModuleCommand("unittest", `discover -s ${start}`));
+}
+function pythonUnittestCoverageCommand(root) {
+  return pythonCommandWithSrcPath(
+    root,
+    pythonModuleCommand("coverage", "run -m unittest discover")
+  );
+}
+function hasPytestSignal(root) {
+  const text = pythonProjectText(root).toLowerCase();
+  return fileExists(root, "pytest.ini") || /\[tool\.pytest\b/.test(text) || /(^|\n)\s*pytest(?:[<>=~! ]|\n|$)/.test(text);
+}
+function hasPythonStdlibUnittestSignal(root) {
+  const testFiles = collectFilesMatching(
+    root,
+    (relativePath, basename) => isPythonUnitTestRelativePath(relativePath, basename),
+    20
+  );
+  return testFiles.some((relativePath) => {
+    const content = readTextFilePrefix(path.join(root, relativePath), 12e3);
+    return /^\s*import\s+unittest(?:\s|$)/m.test(content) || /^\s*from\s+unittest(?:\s|\.|$)/m.test(content) || /\bunittest\.TestCase\b/.test(content) || /\bunittest\.main\s*\(/.test(content);
+  });
+}
+function pythonTestRunners(root) {
+  const unittestCommand = pythonUnittestCommand(root);
+  if (hasPytestSignal(root)) {
+    return {
+      primary: pythonCommandWithSrcPath(root, pythonModuleCommand("pytest")),
+      fallback: unittestCommand !== null && hasPythonStdlibUnittestSignal(root) ? [unittestCommand] : []
+    };
+  }
+  if (unittestCommand !== null) return { primary: unittestCommand, fallback: [] };
+  return { primary: null, fallback: [] };
+}
+function pythonProjectText(root) {
+  return [
+    readTextFile(path.join(root, "pyproject.toml")),
+    readTextFile(path.join(root, "requirements.txt")),
+    readTextFile(path.join(root, "requirements-dev.txt")),
+    readTextFile(path.join(root, "setup.cfg")),
+    readTextFile(path.join(root, "tox.ini")),
+    readTextFile(path.join(root, "mypy.ini"))
+  ].join("\n");
+}
+function hasPythonToolSignal(root, tool) {
+  const text = pythonProjectText(root).toLowerCase();
+  if (tool === "ruff") {
+    return fileExists(root, "ruff.toml") || fileExists(root, ".ruff.toml") || /\[tool\.ruff/.test(text) || /(^|\n)\s*ruff(?:[<>=~! ]|\n|$)/.test(text);
+  }
+  if (tool === "black") {
+    return /\[tool\.black/.test(text) || /(^|\n)\s*black(?:[<>=~! ]|\n|$)/.test(text);
+  }
+  return fileExists(root, "mypy.ini") || /\[tool\.mypy/.test(text) || /\[mypy\]/.test(text) || /(^|\n)\s*mypy(?:[<>=~! ]|\n|$)/.test(text);
+}
+function addPythonQualityCommands(root, verification) {
+  if (hasPythonToolSignal(root, "black")) verification.format.push("black --check .");
+  if (hasPythonToolSignal(root, "ruff")) verification.lint.push("ruff check .");
+  if (hasPythonToolSignal(root, "mypy")) verification.typecheck.push("mypy .");
+}
+function addJvmQualityCommands(root, manifests, verification) {
+  const gradleText = gradleProjectText(root);
+  const gradleCommand = wrapperCommand(root, "gradlew", "gradlew.bat", "gradle");
+  if (manifests.gradle) {
+    verification.build.push(`${gradleCommand} build`);
+    verification.typecheck.push(`${gradleCommand} build`);
+    if (/\bspotless\b|\bcheckstyle\b/.test(gradleText))
+      verification.lint.push(`${gradleCommand} check`);
+    return;
+  }
+  if (manifests.pomXml) {
+    const pomText = readTextFile(path.join(root, "pom.xml")).toLowerCase();
+    const mavenCommand = wrapperCommand(root, "mvnw", "mvnw.cmd", "mvn");
+    verification.build.push(`${mavenCommand} compile`);
+    verification.typecheck.push(`${mavenCommand} compile`);
+    if (pomText.includes("spotless-maven-plugin") || pomText.includes("maven-checkstyle-plugin")) {
+      verification.lint.push(`${mavenCommand} verify`);
+    }
+  }
+}
+function addNativeCommands(root, manifests, verification) {
+  if (manifests.cmakePresets) {
+    const presetsPath = path.join(root, "CMakePresets.json");
+    const buildPreset = firstSafeCMakePresetName(presetsPath, "buildPresets");
+    const testPreset = firstSafeCMakePresetName(presetsPath, "testPresets");
+    if (buildPreset) {
+      verification.build.push(`cmake --build --preset ${buildPreset}`);
+    }
+    if (testPreset) {
+      verification.test.push(`ctest --preset ${testPreset}`);
+    }
+  }
+  const hasCmakeManifest = manifests.cmakeLists || manifests.cmakePresets;
+  if (hasCmakeManifest && !verification.build.some((command) => command.startsWith("cmake --build "))) {
+    if (manifests.buildCMakeCache) {
+      verification.build.push("cmake --build build");
+    }
+  }
+  if (hasCmakeManifest && !verification.test.some((command) => command.startsWith("ctest "))) {
+    if (manifests.buildCTestFile) {
+      verification.test.push("ctest --test-dir build --output-on-failure");
+    }
+  }
+  if (manifests.mesonBuild && manifests.mesonConfigured) {
+    verification.build.push("meson compile -C build");
+    verification.test.push("meson test -C build");
+  }
+}
+function hasCSourceFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => /\.c$/.test(basename));
+}
+function hasCHeaderFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => /\.h$/.test(basename));
+}
+function hasCppSourceFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => {
+    const lower = basename.toLowerCase();
+    return /\.(?:cc|cpp|cxx|c\+\+|hh|hpp|hxx|h\+\+|ipp|ixx)$/.test(lower) || basename.endsWith(".C") || basename.endsWith(".H");
+  });
+}
+function mesonProjectLanguages(root) {
+  const projectArgs = readTextFile(path.join(root, "meson.build")).match(
+    /project\s*\(([\s\S]*?)\)/i
+  )?.[1];
+  if (!projectArgs) return { c: false, cpp: false };
+  return {
+    c: /['"]c['"]/i.test(projectArgs),
+    cpp: /['"]cpp['"]/i.test(projectArgs)
+  };
+}
+function gradleProjectText(root) {
+  const gradleFiles = [
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle",
+    "settings.gradle.kts",
+    ...collectFilesMatching(
+      root,
+      (relativePath, basename) => (basename === "build.gradle" || basename === "build.gradle.kts") && relativePath.includes("/"),
+      20
+    )
+  ];
+  return unique(gradleFiles).map((file) => readTextFile(path.join(root, file))).join("\n").toLowerCase();
+}
+function hasGradleManifest(root) {
+  return fileExists(root, "build.gradle") || fileExists(root, "build.gradle.kts") || hasFileMatching(
+    root,
+    (relativePath, basename) => (basename === "build.gradle" || basename === "build.gradle.kts") && relativePath.includes("/")
+  );
+}
+function hasKotlinSourceFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => {
+    if (basename.endsWith(".kt")) return true;
+    return basename.endsWith(".kts") && !basename.endsWith(".gradle.kts") && basename !== "settings.gradle.kts";
+  });
+}
+function hasGradleKotlinSignal(root) {
+  const gradleText = gradleProjectText(root);
+  return hasKotlinSourceFile(root) || /\bkotlin\s*\(/.test(gradleText) || /\borg\.jetbrains\.kotlin\b/.test(gradleText) || /\bkotlin-android\b/.test(gradleText);
+}
+function hasJavaSourceFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".java"));
+}
+function hasGradleJavaSignal(root) {
+  const gradleText = gradleProjectText(root);
+  return hasJavaSourceFile(root) || /\bid\s*\(?\s*['"](?:java|java-library|application)['"]/.test(gradleText) || /\bapply\s+plugin:\s*['"](?:java|java-library|application)['"]/.test(gradleText);
+}
+function hasSqlSourceFile(root) {
+  return hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".sql"));
+}
+function hasSqlfluffConfig(root) {
+  return fileExists(root, ".sqlfluff") || /\[sqlfluff\]/i.test(readTextFile(path.join(root, "setup.cfg"))) || /\[sqlfluff\]/i.test(readTextFile(path.join(root, "tox.ini"))) || /\[tool\.sqlfluff\]/i.test(readTextFile(path.join(root, "pyproject.toml")));
+}
+function addPackageScriptCommands(root, scripts, verification) {
+  const add = (kind, script) => {
+    if (scripts[script]) verification[kind].push(packageRunCommand(root, script));
+  };
+  add("format", "format:check");
+  add("format", "check:format");
+  add("format", "fmt:check");
+  add("typecheck", "typecheck");
+  add("typecheck", "type-check");
+  add("lint", "lint");
+  add("test", "test:smoke");
+  add("test", "test:unit");
+  add("test", "test:fast");
+  add("test", "test");
+  add("build", "build");
+}
+function addResolverOwnedBiomeLintCommand(root, manifests, verification) {
+  if (!manifests.rootPackageJson) return;
+  if (verification.lint.some((command) => describeVerificationCommand(command).language === "node"))
+    return;
+  if (!hasPackageDependency(root, "@biomejs/biome")) return;
+  if (!hasLocalPackageBin(root, "biome")) return;
+  verification.lint.push(
+    "npx --no-install biome check --changed --no-errors-on-unmatched --reporter=json --formatter-enabled=false --linter-enabled=true ."
+  );
+}
+function addAuditCommands(root, manifests, sourceSignals, audit) {
+  if (manifests.rootPackageJson) {
+    const manager = detectPackageManager(root);
+    if (manager === "npm" && fileExists(root, "package-lock.json")) {
+      audit.push("npm audit --omit=dev --audit-level=high --json");
+    } else if (manager === "pnpm" && fileExists(root, "pnpm-lock.yaml")) {
+      audit.push("pnpm audit --prod --audit-level high --json");
+    } else if (manager === "yarn" && fileExists(root, "yarn.lock")) {
+      audit.push("yarn npm audit --recursive --severity high --json");
+    } else if (manager === "bun" && (fileExists(root, "bun.lockb") || fileExists(root, "bun.lock"))) {
+      audit.push("bun audit --production --json");
+    }
+  }
+  if (sourceSignals.python && hasPythonAuditSignal(root)) {
+    audit.push("pip-audit");
+  }
+  if (sourceSignals.go && manifests.goMod) {
+    audit.push("govulncheck ./...");
+  }
+  if (sourceSignals.rust && manifests.cargoToml) {
+    audit.push("cargo audit");
+  }
+}
+function hasPythonAuditSignal(root) {
+  const text = pythonProjectText(root).toLowerCase();
+  return /(^|\n)\s*pip-audit(?:[<>=~! ]|\n|$)/.test(text) || /\bpip-audit\b/.test(text);
+}
+function hasPythonCoverageSignal(root) {
+  const text = pythonProjectText(root).toLowerCase();
+  return fileExists(root, ".coveragerc") || /\[tool\.coverage/.test(text) || /\[coverage:/.test(text) || /(^|\n)\s*coverage(?:[<>=~! ]|\n|$)/.test(text) || /(^|\n)\s*pytest-cov(?:[<>=~! ]|\n|$)/.test(text) || /\bpytest-cov\b/.test(text);
+}
+function hasRustCoverageSignal(root) {
+  const text = readTextFile(path.join(root, "Cargo.toml")).toLowerCase();
+  return /\bcargo-llvm-cov\b/.test(text) || /\btarpaulin\b/.test(text) || fileExists(root, "tarpaulin.toml");
+}
+var CANONICAL_RUNNER_TASKS = [
+  "test",
+  "lint",
+  "build",
+  "check",
+  "verify"
+];
+function readRunnerTaskNames(root, candidateFiles, runner) {
+  const found = /* @__PURE__ */ new Set();
+  const activeFile = candidateFiles.find((file) => fileExists(root, file));
+  if (activeFile !== void 0) {
+    const text = readTextFilePrefix(path.join(root, activeFile), 64 * 1024);
+    const names = runner === "just" ? readJustRecipeNames(text) : readTaskfileTaskNames(text);
+    for (const kind of CANONICAL_RUNNER_TASKS) {
+      if (names.has(kind)) found.add(kind);
+    }
+  }
+  return CANONICAL_RUNNER_TASKS.filter((kind) => found.has(kind));
+}
+function readJustRecipeNames(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.replace(/\r$/, "");
+    const match = line.match(/^([A-Za-z0-9_-]+)[ \t]*:(?!=)/);
+    if (match?.[1]) names.add(match[1]);
+  }
+  return names;
+}
+function readTaskfileTaskNames(text) {
+  const names = /* @__PURE__ */ new Set();
+  const lines = text.split("\n").map((l) => l.replace(/\r$/, ""));
+  let i = 0;
+  while (i < lines.length) {
+    if (/^tasks:\s*(?:#.*)?$/.test(lines[i] ?? "")) break;
+    i += 1;
+  }
+  if (i >= lines.length) return names;
+  i += 1;
+  let taskKeyIndent = -1;
+  let currentTask;
+  let currentTaskInternal = false;
+  const finalizeCurrent = () => {
+    if (currentTask !== void 0 && !currentTaskInternal) {
+      names.add(currentTask);
+    }
+    currentTask = void 0;
+    currentTaskInternal = false;
+  };
+  for (; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    if (line.trim().length === 0 || line.trim().startsWith("#")) continue;
+    const indent = line.length - line.replace(/^[ ]+/, "").length;
+    if (indent === 0) break;
+    if (taskKeyIndent === -1) taskKeyIndent = indent;
+    if (indent === taskKeyIndent) {
+      finalizeCurrent();
+      const match = line.match(/^[ ]+([A-Za-z0-9_-]+)[ \t]*:(.*)$/);
+      if (match?.[1]) {
+        currentTask = match[1];
+        const inlineRemainder = match[2] ?? "";
+        if (/\binternal:\s*true\b/i.test(inlineRemainder)) {
+          currentTaskInternal = true;
+        }
+      }
+      continue;
+    }
+    if (currentTask !== void 0 && /^\s*internal:\s*true\s*(?:#.*)?$/i.test(line)) {
+      currentTaskInternal = true;
+    }
+  }
+  finalizeCurrent();
+  return names;
+}
+function addCoverageCommands(root, scripts, manifests, sourceSignals, coverage) {
+  if (manifests.rootPackageJson && scripts["test:coverage"]) {
+    coverage.push(packageRunCommand(root, "test:coverage"));
+  }
+  if (sourceSignals.go && manifests.goMod) {
+    coverage.push("go test -cover ./...");
+  }
+  if (sourceSignals.python && hasPythonCoverageSignal(root)) {
+    if (hasPytestSignal(root)) {
+      coverage.push(pythonCommandWithSrcPath(root, `${pythonModuleCommand("pytest")} --cov`));
+    } else if (pythonUnittestDiscoveryRoot(root) !== null) {
+      coverage.push(pythonUnittestCoverageCommand(root));
+    }
+  }
+  if (sourceSignals.rust && manifests.cargoToml && hasRustCoverageSignal(root)) {
+    const text = readTextFile(path.join(root, "Cargo.toml")).toLowerCase();
+    coverage.push(/\bcargo-llvm-cov\b/.test(text) ? "cargo llvm-cov" : "cargo tarpaulin");
+  }
+}
+function readTurboTaskNames(root) {
+  const tasks = /* @__PURE__ */ new Set();
+  const sources = [];
+  const turboJson = readJsonFile(path.join(root, "turbo.json"));
+  if (turboJson) sources.push(turboJson.tasks, turboJson.pipeline);
+  const pkg = readJsonFile(path.join(root, "package.json"));
+  const pkgTurbo = pkg?.turbo;
+  if (pkgTurbo && typeof pkgTurbo === "object" && !Array.isArray(pkgTurbo)) {
+    const turboConfig = pkgTurbo;
+    sources.push(turboConfig.tasks, turboConfig.pipeline);
+  }
+  for (const source of sources) {
+    if (source && typeof source === "object" && !Array.isArray(source)) {
+      for (const key of Object.keys(source)) {
+        const taskName = key.includes("#") ? key.split("#").pop() ?? key : key;
+        if (taskName.length > 0) tasks.add(taskName);
+      }
+    }
+  }
+  return tasks;
+}
+function addTurboTaskCommands(root, scripts, verification) {
+  const taskNames = readTurboTaskNames(root);
+  if (taskNames.size === 0) return;
+  const rootScriptCovered = /* @__PURE__ */ new Set(["build", "lint", "typecheck", "test"]);
+  const turboTaskBuckets = [
+    { task: "build", kind: "build" },
+    { task: "check", kind: "test" },
+    { task: "lint", kind: "lint" },
+    { task: "test", kind: "test" },
+    { task: "typecheck", kind: "typecheck" },
+    { task: "verify", kind: "test" }
+  ];
+  for (const { task, kind } of turboTaskBuckets) {
+    if (!taskNames.has(task)) continue;
+    if (rootScriptCovered.has(task) && scripts[task]) continue;
+    verification[kind].push(`turbo run ${task}`);
+  }
+}
+function hasJavaScriptTestFile(root) {
+  return hasFileMatching(
+    root,
+    (_relativePath, basename) => /\.(test|spec)\.(js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(basename)
+  );
+}
+function hasProjectTestFile(root) {
+  return hasFileMatching(root, (relativePath) => isProjectTestPath(relativePath));
+}
+function addDotnetCommands(root, manifests, verification) {
+  if (!manifests.dotnetSolution && !manifests.dotnetProject) return;
+  verification.format.push("dotnet format --verify-no-changes");
+  verification.build.push("dotnet build");
+  verification.typecheck.push("dotnet build");
+  if (hasProjectTestFile(root)) {
+    verification.test.push("dotnet test");
+  }
+}
+function addSwiftCommands(root, manifests, verification) {
+  if (!manifests.packageSwift) return;
+  verification.build.push("swift build");
+  const hasSwiftTests = hasFileMatching(root, (relativePath, basename) => {
+    const normalized = relativePath.replace(/\\/g, "/");
+    return normalized.startsWith("Tests/") || basename.endsWith("Tests.swift") || basename.endsWith("Test.swift");
+  });
+  if (hasSwiftTests) verification.test.push("swift test");
+}
+function pubspecText(root) {
+  return readTextFile(path.join(root, "pubspec.yaml")).toLowerCase();
+}
+function addDartCommands(root, manifests, verification) {
+  if (!manifests.pubspecYaml) return;
+  const text = pubspecText(root);
+  const isFlutter = /^\s*flutter\s*:/m.test(text) || /(^|\n)\s*sdk\s*:\s*flutter\b/.test(text);
+  const hasDartTests = hasFileMatching(root, (relativePath, basename) => {
+    const normalized = relativePath.replace(/\\/g, "/").toLowerCase();
+    return (normalized.startsWith("test/") || normalized.startsWith("integration_test/")) && basename.endsWith("_test.dart");
+  });
+  if (isFlutter) {
+    verification.lint.push("flutter analyze");
+    if (hasDartTests) verification.test.push("flutter test");
+  } else {
+    verification.lint.push("dart analyze");
+    if (hasDartTests || /(^|\n)\s*test\s*:/.test(text)) verification.test.push("dart test");
+  }
+}
+function addShellCommands(root, verification) {
+  const shellFiles = collectFilesMatching(
+    root,
+    (relativePath, basename) => /\.(?:sh|bash|zsh)$/.test(basename) && !basename.startsWith("-") && !/[^\w./-]/.test(relativePath),
+    20
+  );
+  if (shellFiles.length === 0) return;
+  if (fileExists(root, ".shellcheckrc") || fileExists(root, "shellcheckrc")) {
+    verification.lint.push(`shellcheck ${shellFiles.join(" ")}`);
+  }
+}
+function addRCommands(manifests, verification) {
+  if (manifests.rDescription) {
+    verification.test.push("R CMD check .");
+  }
+}
+function addSqlCommands(manifests, verification) {
+  if (manifests.dbtProject) {
+    verification.build.push("dbt compile");
+    verification.test.push("dbt test");
+  }
+  if (manifests.sqlfluffConfig) {
+    verification.lint.push("sqlfluff lint .");
+  }
+}
+function hasBundlerInstallSignal(root) {
+  return existsSync(path.join(root, "vendor", "bundle")) || existsSync(path.join(root, ".bundle", "config"));
+}
+function addRubyCommands(root, manifests, verification) {
+  if (manifests.gemfile && !hasBundlerInstallSignal(root)) return;
+  const bundlePrefix = manifests.gemfile ? "bundle exec " : "";
+  const gemfileText = readTextFile(path.join(root, "Gemfile"));
+  const gemspecText = collectFilesMatching(
+    root,
+    (_relativePath, basename) => basename.endsWith(".gemspec"),
+    5
+  ).map((file) => readTextFile(path.join(root, file))).join("\n");
+  const rubyText = `${gemfileText}
+${gemspecText}`;
+  const hasRspec = /\brspec\b/i.test(rubyText) || hasFileMatching(
+    root,
+    (relativePath, basename) => relativePath.startsWith("spec/") || basename.endsWith("_spec.rb")
+  );
+  const hasMinitest = hasProjectTestFile(root);
+  if (manifests.rubocop || /\brubocop\b/i.test(rubyText)) {
+    verification.lint.push(`${bundlePrefix}rubocop`.trim());
+  }
+  if (hasRspec) {
+    verification.test.push(`${bundlePrefix}rspec`.trim());
+  } else if (manifests.rakefile && hasMinitest) {
+    verification.test.push(`${bundlePrefix}rake test`.trim());
+  }
+}
+function hasComposerInstallSignal(root) {
+  return existsSync(path.join(root, "vendor", "autoload.php")) || existsSync(path.join(root, "vendor", "bin"));
+}
+function addPhpCommands(root, composerScripts, manifests, verification) {
+  if (manifests.composerJson && !hasComposerInstallSignal(root)) return;
+  const addComposerScript = (kind, script) => {
+    if (composerScripts[script]) verification[kind].push(`composer run ${script}`);
+  };
+  addComposerScript("test", "test");
+  addComposerScript("lint", "lint");
+  addComposerScript("typecheck", "typecheck");
+  addComposerScript("typecheck", "analyse");
+  addComposerScript("typecheck", "analyze");
+  addComposerScript("build", "build");
+  if (manifests.composerJson) {
+    if (manifests.phpunit && !composerScripts.test) {
+      verification.test.push("composer exec -- phpunit");
+    }
+    if (manifests.phpstan && !composerScripts.typecheck && !composerScripts.analyse) {
+      verification.typecheck.push("composer exec -- phpstan analyse");
+    }
+    if (manifests.psalm && !composerScripts.typecheck) {
+      verification.typecheck.push("composer exec -- psalm");
+    }
+  }
+}
+function addMakeCommands(root, verification) {
+  const makefile = ["Makefile", "makefile"].find((file) => fileExists(root, file));
+  if (!makefile) return;
+  let content = "";
+  try {
+    content = readFileSync(path.join(root, makefile), "utf8");
+  } catch {
+    return;
+  }
+  const hasTarget = (name) => new RegExp(`^${name}:`, "m").test(content);
+  if (hasTarget("check")) verification.test.push("make check");
+  if (hasTarget("test")) verification.test.push("make test");
+  if (hasTarget("lint")) verification.lint.push("make lint");
+  if (hasTarget("build")) verification.build.push("make build");
+  if (hasTarget("verify")) verification.test.push("make verify");
+}
+function unique(items) {
+  return Array.from(new Set(items));
+}
+function mergeVerificationCommands(base, override) {
+  const merged = {
+    format: unique(override.format ?? base.format),
+    build: unique(override.build ?? base.build),
+    typecheck: unique(override.typecheck ?? base.typecheck),
+    lint: unique(override.lint ?? base.lint),
+    test: unique(override.test ?? base.test),
+    testFallback: unique(override.testFallback ?? base.testFallback)
+  };
+  const audit = unique(override.audit ?? base.audit ?? []);
+  if (audit.length > 0) merged.audit = audit;
+  const coverage = unique(override.coverage ?? base.coverage ?? []);
+  if (coverage.length > 0) merged.coverage = coverage;
+  return merged;
+}
+function detectDocsOnly(root, languages) {
+  if (languages.some((language) => language !== "docs" && language !== "unknown")) {
+    return false;
+  }
+  const docsSignals = ["README.md", "README", "docs", "CHANGELOG.md", "LICENSE"].some(
+    (entry) => existsSync(path.join(root, entry))
+  );
+  return docsSignals;
+}
+function wrapperCommand(root, unixWrapper, windowsWrapper, fallback) {
+  if (process.platform === "win32" && fileExists(root, windowsWrapper))
+    return `.${path.sep}${windowsWrapper}`;
+  if (fileExists(root, unixWrapper)) return `./${unixWrapper}`;
+  return fallback;
+}
+function detectProjectCapabilities(root) {
+  const buildDirectorySafe = directoryStaysInsideRoot(root, "build");
+  const manifests = {
+    packageJson: fileExists(root, "package.json") || hasFileMatching(
+      root,
+      (relativePath, basename) => relativePath.includes("/") && basename === "package.json"
+    ),
+    // ROOT-only package.json signal (distinct from `packageJson`, which is ALSO
+    // true for a merely-nested manifest). The Node fast/scoped path runs ROOT
+    // npm-script-based commands, so it must gate on a ROOT package.json existing
+    // — mirroring `isNodeLikeTarget`'s `existsSync(path.join(root,'package.json'))`
+    // in src/planning/quality-presets.ts. A nested-only manifest is NOT a root
+    // Node surface and must fall through to the resolver-backed language path.
+    rootPackageJson: fileExists(root, "package.json"),
+    denoJson: fileExists(root, "deno.json") || fileExists(root, "deno.jsonc"),
+    tsconfig: fileExists(root, "tsconfig.json") || fileExists(root, "tsconfig.typecheck.json"),
+    pyproject: fileExists(root, "pyproject.toml"),
+    requirements: fileExists(root, "requirements.txt"),
+    goMod: fileExists(root, "go.mod"),
+    cargoToml: fileExists(root, "Cargo.toml"),
+    pomXml: fileExists(root, "pom.xml"),
+    gradle: hasGradleManifest(root),
+    cmakeLists: fileExists(root, "CMakeLists.txt"),
+    cmakePresets: fileExists(root, "CMakePresets.json"),
+    mesonBuild: fileExists(root, "meson.build"),
+    buildCMakeCache: buildDirectorySafe && fileExists(root, path.join("build", "CMakeCache.txt")),
+    buildCTestFile: buildDirectorySafe && fileExists(root, path.join("build", "CTestTestfile.cmake")),
+    buildNinja: buildDirectorySafe && fileExists(root, path.join("build", "build.ninja")),
+    mesonConfigured: buildDirectorySafe && fileExists(root, path.join("build", "meson-private")),
+    dotnetSolution: hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".sln")),
+    dotnetProject: hasFileMatching(
+      root,
+      (_relativePath, basename) => /\.(csproj|fsproj|vbproj)$/.test(basename)
+    ),
+    gemfile: fileExists(root, "Gemfile"),
+    gemspec: hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".gemspec")),
+    rakefile: fileExists(root, "Rakefile"),
+    rubocop: fileExists(root, ".rubocop.yml") || fileExists(root, ".rubocop.yaml"),
+    packageSwift: fileExists(root, "Package.swift"),
+    pubspecYaml: fileExists(root, "pubspec.yaml"),
+    composerJson: fileExists(root, "composer.json"),
+    composerLock: fileExists(root, "composer.lock"),
+    phpunit: fileExists(root, "phpunit.xml") || fileExists(root, "phpunit.xml.dist"),
+    phpstan: fileExists(root, "phpstan.neon") || fileExists(root, "phpstan.neon.dist"),
+    psalm: fileExists(root, "psalm.xml") || fileExists(root, "psalm.xml.dist"),
+    dbtProject: fileExists(root, "dbt_project.yml") || fileExists(root, "dbt_project.yaml"),
+    sqlfluffConfig: hasSqlfluffConfig(root),
+    rDescription: fileExists(root, "DESCRIPTION"),
+    renvLock: fileExists(root, "renv.lock"),
+    rProject: hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".Rproj")),
+    shellcheckConfig: fileExists(root, ".shellcheckrc") || fileExists(root, "shellcheckrc"),
+    pesterConfig: fileExists(root, "PesterConfiguration.ps1"),
+    // PowerShell static-analysis config (PSScriptAnalyzer settings). Drives the
+    // PowerShell lint command in the additive IaC/runner/PowerShell derivation.
+    scriptAnalyzerConfig: fileExists(root, "PSScriptAnalyzerSettings.psd1"),
+    makefile: fileExists(root, "Makefile") || fileExists(root, "makefile"),
+    mavenWrapper: fileExists(root, "mvnw") || fileExists(root, "mvnw.cmd"),
+    gradleWrapper: fileExists(root, "gradlew") || fileExists(root, "gradlew.bat"),
+    // --- Static IaC surfaces (additive verification-coverage lane) ---------
+    // `dockerfile` is kept DISTINCT from `dockerCompose`: a Compose file is not a
+    // Dockerfile and must not trigger `hadolint Dockerfile`.
+    dockerfile: fileExists(root, "Dockerfile"),
+    // hadolint is a separate binary from Docker; gate it on its own dedicated
+    // config (`.hadolint.yaml`/`.hadolint.yml`) rather than the presence of a
+    // Dockerfile, so a plain Docker repo does not emit a command-not-found
+    // `hadolint` failure (mirrors the `tflintConfig` gate).
+    hadolintConfig: fileExists(root, ".hadolint.yaml") || fileExists(root, ".hadolint.yml"),
+    dockerCompose: fileExists(root, "docker-compose.yml") || fileExists(root, "docker-compose.yaml") || fileExists(root, "compose.yml") || fileExists(root, "compose.yaml"),
+    // Any `*.tf` file anywhere in the tree signals Terraform configuration.
+    terraform: hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".tf")),
+    // tflint is a separate binary from the Terraform CLI; gate it on its own
+    // dedicated config (`.tflint.hcl`) rather than the presence of `*.tf`, so a
+    // plain Terraform repo does not emit a command-not-found `tflint` failure.
+    tflintConfig: fileExists(root, ".tflint.hcl"),
+    // golangci-lint is a separate binary from the Go toolchain; gate it on its
+    // own dedicated config file rather than the presence of go.mod, so a plain
+    // Go repo does not emit a command-not-found `golangci-lint` failure
+    // (mirrors the `tflintConfig`/`hadolintConfig` real-toolchain-signal gates).
+    golangciLintConfig: fileExists(root, ".golangci.yml") || fileExists(root, ".golangci.yaml") || fileExists(root, ".golangci.toml") || fileExists(root, ".golangci.json"),
+    // Conservative Kubernetes-manifest heuristic. Scanning every YAML for
+    // `apiVersion:`+`kind:` is too I/O-heavy, so we use cheap structural signals
+    // only: a `k8s/` or `kubernetes/` directory, or a kustomization file at root.
+    // This intentionally UNDER-detects (e.g. manifests in an oddly-named dir) to
+    // stay fail-closed: a missed manifest emits no command rather than a wrong one.
+    kubernetesManifests: directoryStaysInsideRoot(root, "k8s") || directoryStaysInsideRoot(root, "kubernetes") || fileExists(root, "kustomization.yaml") || fileExists(root, "kustomization.yml"),
+    // --- Custom task runners (just / task) --------------------------------
+    justfile: fileExists(root, "justfile") || fileExists(root, ".justfile") || fileExists(root, "Justfile"),
+    taskfile: fileExists(root, "Taskfile.yml") || fileExists(root, "Taskfile.yaml") || fileExists(root, "taskfile.yml") || fileExists(root, "taskfile.yaml") || fileExists(root, "Taskfile.dist.yml") || fileExists(root, "Taskfile.dist.yaml")
+  };
+  const mesonLanguages = manifests.mesonBuild ? mesonProjectLanguages(root) : { c: false, cpp: false };
+  const hasCppSource = hasCppSourceFile(root) || mesonLanguages.cpp;
+  const sourceSignals = {
+    typescript: manifests.tsconfig || manifests.denoJson || hasFileMatching(root, (_relativePath, basename) => /\.(?:ts|tsx|mts|cts)$/.test(basename)),
+    javascript: manifests.rootPackageJson || manifests.denoJson || hasFileMatching(root, (_relativePath, basename) => /\.(?:js|jsx|mjs|cjs)$/.test(basename)),
+    c: hasCSourceFile(root) || mesonLanguages.c || !hasCppSource && hasCHeaderFile(root),
+    cpp: hasCppSource,
+    python: manifests.pyproject || manifests.requirements || fileExists(root, "poetry.lock") || fileExists(root, "Pipfile") || fileExists(root, "Pipfile.lock") || fileExists(root, "pytest.ini") || fileExists(root, "setup.py") || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".py")),
+    go: manifests.goMod || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".go")),
+    rust: manifests.cargoToml || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".rs")),
+    java: !manifests.gradle && manifests.pomXml || hasGradleJavaSignal(root),
+    dotnet: manifests.dotnetSolution || manifests.dotnetProject,
+    swift: manifests.packageSwift || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".swift")),
+    kotlin: hasFileMatching(root, (_relativePath, basename) => basename === "AndroidManifest.xml") || hasGradleKotlinSignal(root),
+    dart: manifests.pubspecYaml || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".dart")),
+    ruby: manifests.gemfile || manifests.gemspec || manifests.rakefile || manifests.rubocop || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".rb")),
+    php: manifests.composerJson || manifests.composerLock || manifests.phpunit || manifests.phpstan || manifests.psalm || hasFileMatching(root, (_relativePath, basename) => basename.endsWith(".php")),
+    shell: hasFileMatching(
+      root,
+      (_relativePath, basename) => /\.(?:sh|bash|fish|ksh|zsh)$/.test(basename)
+    ),
+    powershell: manifests.pesterConfig || hasFileMatching(root, (_relativePath, basename) => /\.(?:ps1|psm1|psd1)$/i.test(basename)),
+    r: manifests.rDescription || manifests.rProject || hasFileMatching(root, (_relativePath, basename) => /\.(?:r|R|Rmd|Rnw)$/i.test(basename)),
+    sql: manifests.dbtProject || hasSqlSourceFile(root)
+  };
+  const languages = /* @__PURE__ */ new Set();
+  if (manifests.rootPackageJson) {
+    languages.add("node");
+    languages.add(sourceSignals.typescript ? "typescript" : "javascript");
+  }
+  if (!manifests.rootPackageJson && sourceSignals.typescript) languages.add("typescript");
+  if (!manifests.rootPackageJson && sourceSignals.javascript) languages.add("javascript");
+  if (sourceSignals.c) languages.add("c");
+  if (sourceSignals.cpp) languages.add("cpp");
+  if (sourceSignals.python) languages.add("python");
+  if (sourceSignals.go) languages.add("go");
+  if (sourceSignals.rust) languages.add("rust");
+  if (sourceSignals.java) languages.add("java");
+  if (sourceSignals.dotnet) languages.add("dotnet");
+  if (sourceSignals.swift) languages.add("swift");
+  if (sourceSignals.kotlin) languages.add("kotlin");
+  if (sourceSignals.dart) languages.add("dart");
+  if (sourceSignals.ruby) languages.add("ruby");
+  if (sourceSignals.php) languages.add("php");
+  if (sourceSignals.shell) languages.add("shell");
+  if (sourceSignals.powershell) languages.add("powershell");
+  if (sourceSignals.r) languages.add("r");
+  if (sourceSignals.sql) languages.add("sql");
+  if (languages.size === 0) {
+    const initialLanguages = [];
+    if (detectDocsOnly(root, initialLanguages)) languages.add("docs");
+  }
+  if (languages.size === 0) languages.add("unknown");
+  const packageScripts = readPackageScripts(root);
+  const composerScripts = readComposerScripts(root);
+  const verification = {
+    format: [],
+    build: [],
+    typecheck: [],
+    lint: [],
+    test: [],
+    testFallback: []
+  };
+  addPackageScriptCommands(root, packageScripts, verification);
+  if (manifests.packageJson) {
+    addTurboTaskCommands(root, packageScripts, verification);
+  }
+  if (manifests.packageJson && detectPackageManager(root) === "bun" && !packageScripts.test && hasJavaScriptTestFile(root)) {
+    verification.test.push("bun test");
+  }
+  addMakeCommands(root, verification);
+  addNativeCommands(root, manifests, verification);
+  if (sourceSignals.python) {
+    addPythonQualityCommands(root, verification);
+    const pythonRunners = pythonTestRunners(root);
+    if (pythonRunners.primary) verification.test.push(pythonRunners.primary);
+    for (const fallback of pythonRunners.fallback) {
+      verification.testFallback.push(fallback);
+    }
+  }
+  if (manifests.goMod) {
+    verification.lint.push("go vet ./...");
+    if (manifests.golangciLintConfig) {
+      verification.lint.push("golangci-lint run");
+    }
+    verification.typecheck.push('go test ./... -run "^$"');
+    verification.test.push("go test ./...");
+    verification.build.push("go build ./...");
+  }
+  if (manifests.cargoToml) {
+    verification.format.push("cargo fmt --check");
+    verification.lint.push("cargo clippy --locked --all-targets --all-features -- -D warnings");
+    verification.typecheck.push("cargo check --locked");
+    verification.test.push("cargo test --locked");
+    verification.build.push("cargo build --locked");
+  }
+  if (sourceSignals.swift) addSwiftCommands(root, manifests, verification);
+  if (sourceSignals.dart) addDartCommands(root, manifests, verification);
+  addJvmQualityCommands(root, manifests, verification);
+  if (manifests.gradle) {
+    verification.test.push(`${wrapperCommand(root, "gradlew", "gradlew.bat", "gradle")} test`);
+  } else if (manifests.pomXml) {
+    verification.test.push(`${wrapperCommand(root, "mvnw", "mvnw.cmd", "mvn")} test`);
+  }
+  addDotnetCommands(root, manifests, verification);
+  if (sourceSignals.shell) addShellCommands(root, verification);
+  if (sourceSignals.r) addRCommands(manifests, verification);
+  if (sourceSignals.sql) addSqlCommands(manifests, verification);
+  if (sourceSignals.ruby) addRubyCommands(root, manifests, verification);
+  if (sourceSignals.php) addPhpCommands(root, composerScripts, manifests, verification);
+  addResolverOwnedBiomeLintCommand(root, manifests, verification);
+  const hadSourceLint = verification.lint.length > 0;
+  const hadSourceTest = verification.test.length > 0;
+  const hadSourceBuild = verification.build.length > 0;
+  if (manifests.dockerfile || manifests.terraform || manifests.kubernetesManifests) {
+    for (const command of buildIacLintCommands({
+      dockerfile: manifests.dockerfile,
+      hadolintConfig: manifests.hadolintConfig,
+      terraform: manifests.terraform,
+      tflintConfig: manifests.tflintConfig,
+      kubernetesManifests: manifests.kubernetesManifests
+    })) {
+      verification.lint.push(command);
+    }
+  }
+  if (manifests.justfile || manifests.taskfile) {
+    const runnerDetecteds = [];
+    if (manifests.justfile) {
+      const justTasks = readRunnerTaskNames(root, ["justfile", ".justfile", "Justfile"], "just");
+      if (justTasks.length > 0) {
+        runnerDetecteds.push({ just: true, task: false, availableTasks: justTasks });
+      }
+    }
+    if (manifests.taskfile) {
+      const taskTasks = readRunnerTaskNames(
+        root,
+        [
+          "Taskfile.yml",
+          "Taskfile.yaml",
+          "taskfile.yml",
+          "taskfile.yaml",
+          "Taskfile.dist.yml",
+          "Taskfile.dist.yaml"
+        ],
+        "task"
+      );
+      if (taskTasks.length > 0) {
+        runnerDetecteds.push({ just: false, task: true, availableTasks: taskTasks });
+      }
+    }
+    if (!hadSourceTest) {
+      for (const runnerDetected of runnerDetecteds) {
+        for (const command of buildRunnerCommands(runnerDetected, "test")) {
+          verification.test.push(command);
+        }
+      }
+    }
+    if (!hadSourceBuild) {
+      for (const runnerDetected of runnerDetecteds) {
+        for (const command of buildRunnerCommands(runnerDetected, "build")) {
+          verification.build.push(command);
+        }
+      }
+    }
+    if (!hadSourceLint) {
+      let runnerEmittedLint = false;
+      for (const runnerDetected of runnerDetecteds) {
+        const before = verification.lint.length;
+        for (const command of buildRunnerCommands(runnerDetected, "lint")) {
+          verification.lint.push(command);
+        }
+        if (verification.lint.length > before) runnerEmittedLint = true;
+      }
+      if (!runnerEmittedLint) {
+        for (const runnerDetected of runnerDetecteds) {
+          for (const kind of ["check", "verify"]) {
+            const beforeKind = verification.lint.length;
+            for (const command of buildRunnerCommands(runnerDetected, kind)) {
+              verification.lint.push(command);
+            }
+            if (verification.lint.length > beforeKind) {
+              runnerEmittedLint = true;
+              break;
+            }
+          }
+          if (runnerEmittedLint) break;
+        }
+      }
+    }
+  }
+  if (sourceSignals.powershell) {
+    const powershell = buildPowerShellCommands({
+      pesterConfig: manifests.pesterConfig,
+      scriptAnalyzerConfig: manifests.scriptAnalyzerConfig,
+      hasPowerShellSources: sourceSignals.powershell
+    });
+    for (const command of powershell.test) verification.test.push(command);
+    for (const command of powershell.lint) verification.lint.push(command);
+  }
+  const auditCommands = [];
+  const coverageCommands = [];
+  addAuditCommands(root, manifests, sourceSignals, auditCommands);
+  addCoverageCommands(root, packageScripts, manifests, sourceSignals, coverageCommands);
+  const mergedVerification = mergeVerificationCommands(
+    {
+      format: unique(verification.format),
+      build: unique(verification.build),
+      typecheck: unique(verification.typecheck),
+      lint: unique(verification.lint),
+      test: unique(verification.test),
+      testFallback: unique(verification.testFallback),
+      audit: unique(auditCommands),
+      coverage: unique(coverageCommands)
+    },
+    readVerificationOverrides(root)
+  );
+  const detectedLanguages = Array.from(languages);
+  return {
+    root,
+    languages: detectedLanguages,
+    manifests,
+    packageScripts,
+    composerScripts,
+    verification: mergedVerification,
+    docsOnly: detectDocsOnly(root, detectedLanguages)
+  };
+}
+function hasProjectLanguage(capabilities, language) {
+  return capabilities.languages.includes(language);
+}
+
+export {
+  isNonPackageStaticLintCommand,
+  isIacStaticCommand,
+  isIacProjectPath,
+  isPowerShellStaticCommand,
+  PROJECT_LANGUAGES,
+  PROJECT_IGNORED_DIRECTORIES,
+  isIgnoredProjectPath,
+  detectPackageManager,
+  buildPackageScriptCommand,
+  detectProjectCapabilities,
+  hasProjectLanguage
+};
+//# sourceMappingURL=chunk-FHOWVDF5.js.map