opencode-swarm 7.184.10 → 7.184.12

package/dist/cli/index-7bxssqaf.js

@@ -0,0 +1,2676 @@
+// @bun
+import {
+  tool
+} from "./index-9nyqt3kb.js";
+import {
+  bunSpawnSync
+} from "./index-2s7dvzff.js";
+import {
+  simpleGlobToRegex
+} from "./index-c1ggtmpm.js";
+import {
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/lang/detector.ts
+import { access, readdir } from "fs/promises";
+import { extname, join } from "path";
+
+// src/lang/profiles.ts
+class LanguageRegistry {
+  profiles;
+  extensionIndex;
+  constructor() {
+    this.profiles = new Map;
+    this.extensionIndex = new Map;
+  }
+  unregister(id) {
+    const profile = this.profiles.get(id);
+    if (!profile)
+      return;
+    this.profiles.delete(id);
+    if (!profile.parserOnly) {
+      for (const ext of profile.extensions) {
+        if (this.extensionIndex.get(ext) === id) {
+          this.extensionIndex.delete(ext);
+        }
+      }
+    }
+  }
+  register(profile) {
+    const existing = this.profiles.get(profile.id);
+    if (existing && existing !== profile) {
+      throw new Error(`LanguageRegistry: profile id "${profile.id}" registered twice. ` + `Each LanguageProfile.id must be unique. ` + `Got: ${profile.displayName} vs existing ${existing.displayName}.`);
+    }
+    if (!profile.parserOnly) {
+      for (const ext of profile.extensions) {
+        const claimedBy = this.extensionIndex.get(ext);
+        if (claimedBy && claimedBy !== profile.id) {
+          throw new Error(`LanguageRegistry: extension "${ext}" registered by both ` + `"${claimedBy}" and "${profile.id}". A non-parserOnly profile ` + `must not collide on extensions. If both languages legitimately ` + `share an extension, mark one parserOnly: true.`);
+        }
+        this.extensionIndex.set(ext, profile.id);
+      }
+    }
+    this.profiles.set(profile.id, profile);
+  }
+  get(id) {
+    return this.profiles.get(id);
+  }
+  getById(id) {
+    return this.profiles.get(id);
+  }
+  getByExtension(ext) {
+    const profileId = this.extensionIndex.get(ext);
+    if (profileId) {
+      return this.profiles.get(profileId);
+    }
+    return;
+  }
+  getAll() {
+    return Array.from(this.profiles.values());
+  }
+  getTier(tier) {
+    return Array.from(this.profiles.values()).filter((p) => p.tier === tier);
+  }
+}
+var LANGUAGE_REGISTRY = new LanguageRegistry;
+LANGUAGE_REGISTRY.register({
+  id: "typescript",
+  displayName: "TypeScript",
+  tier: 1,
+  extensions: [".ts", ".tsx"],
+  treeSitter: {
+    grammarId: "typescript",
+    wasmFile: "tree-sitter-typescript.wasm",
+    commentNodes: ["comment", "line_comment", "block_comment"]
+  },
+  build: {
+    detectFiles: ["package.json"],
+    commands: [
+      {
+        name: "bun build",
+        cmd: "bun run build",
+        detectFile: "package.json",
+        priority: 10
+      },
+      {
+        name: "tsc",
+        cmd: "tsc --noEmit",
+        detectFile: "tsconfig.json",
+        priority: 9
+      },
+      {
+        name: "vite build",
+        cmd: "vite build",
+        detectFile: "vite.config.ts",
+        priority: 8
+      }
+    ]
+  },
+  test: {
+    detectFiles: [
+      "package.json",
+      "vitest.config.ts",
+      "jest.config.js",
+      ".mocharc.js",
+      ".mocharc.json"
+    ],
+    frameworks: [
+      {
+        name: "vitest",
+        detect: "vitest.config.ts",
+        cmd: "bun test",
+        priority: 10
+      },
+      { name: "jest", detect: "jest.config.js", cmd: "jest", priority: 9 },
+      {
+        name: "bun:test",
+        detect: "bun.lock",
+        cmd: "bun test",
+        priority: 8
+      },
+      {
+        name: "mocha",
+        detect: ".mocharc.json",
+        cmd: "mocha",
+        priority: 7
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [
+      "biome.json",
+      "biome.jsonc",
+      ".eslintrc.js",
+      ".eslintrc.json"
+    ],
+    linters: [
+      {
+        name: "biome",
+        detect: "biome.json",
+        cmd: "biome check --write .",
+        priority: 10
+      },
+      {
+        name: "eslint",
+        detect: ".eslintrc.js",
+        cmd: "eslint --fix .",
+        priority: 9
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["package.json"],
+    command: "npm audit --json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "javascript", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Use strict TypeScript; no implicit any or type assertions without justification",
+      "Prefer async/await over raw Promises; always handle rejections",
+      "Use const/let, never var; prefer immutable data structures",
+      "Follow existing import style (ESM); no require() in .ts files",
+      "Add JSDoc for all exported functions and types"
+    ],
+    reviewerChecklist: [
+      "Verify no implicit any or unsafe type casts",
+      "Check async error handling \u2014 unhandled Promises are bugs",
+      "Confirm ESM import consistency (no mixed require/import)",
+      "Validate exported API surface matches declared types",
+      "Check for missing null/undefined guards on optional fields"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "javascript",
+  displayName: "JavaScript",
+  tier: 1,
+  extensions: [".js", ".jsx", ".mjs", ".cjs"],
+  treeSitter: {
+    grammarId: "javascript",
+    wasmFile: "tree-sitter-javascript.wasm",
+    commentNodes: ["comment", "line_comment", "block_comment"]
+  },
+  build: {
+    detectFiles: ["package.json"],
+    commands: [
+      {
+        name: "bun build",
+        cmd: "bun run build",
+        detectFile: "package.json",
+        priority: 10
+      },
+      {
+        name: "tsc",
+        cmd: "tsc --noEmit",
+        detectFile: "tsconfig.json",
+        priority: 9
+      },
+      {
+        name: "vite build",
+        cmd: "vite build",
+        detectFile: "vite.config.ts",
+        priority: 8
+      }
+    ]
+  },
+  test: {
+    detectFiles: [
+      "package.json",
+      "vitest.config.ts",
+      "jest.config.js",
+      ".mocharc.js",
+      ".mocharc.json"
+    ],
+    frameworks: [
+      {
+        name: "vitest",
+        detect: "vitest.config.ts",
+        cmd: "bun test",
+        priority: 10
+      },
+      { name: "jest", detect: "jest.config.js", cmd: "jest", priority: 9 },
+      {
+        name: "bun:test",
+        detect: "bun.lock",
+        cmd: "bun test",
+        priority: 8
+      },
+      {
+        name: "mocha",
+        detect: ".mocharc.json",
+        cmd: "mocha",
+        priority: 7
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [
+      "biome.json",
+      "biome.jsonc",
+      ".eslintrc.js",
+      ".eslintrc.json"
+    ],
+    linters: [
+      {
+        name: "biome",
+        detect: "biome.json",
+        cmd: "biome check --write .",
+        priority: 10
+      },
+      {
+        name: "eslint",
+        detect: ".eslintrc.js",
+        cmd: "eslint --fix .",
+        priority: 9
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["package.json"],
+    command: "npm audit --json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "javascript", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Use strict TypeScript; no implicit any or type assertions without justification",
+      "Prefer async/await over raw Promises; always handle rejections",
+      "Use const/let, never var; prefer immutable data structures",
+      "Follow existing import style (ESM); no require() in .ts files",
+      "Add JSDoc for all exported functions and types"
+    ],
+    reviewerChecklist: [
+      "Verify no implicit any or unsafe type casts",
+      "Check async error handling \u2014 unhandled Promises are bugs",
+      "Confirm ESM import consistency (no mixed require/import)",
+      "Validate exported API surface matches declared types",
+      "Check for missing null/undefined guards on optional fields"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "python",
+  displayName: "Python",
+  tier: 1,
+  extensions: [".py", ".pyw"],
+  treeSitter: {
+    grammarId: "python",
+    wasmFile: "tree-sitter-python.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["setup.py", "pyproject.toml", "setup.cfg"],
+    commands: [
+      {
+        name: "pip install",
+        cmd: "pip install -e .",
+        detectFile: "setup.py",
+        priority: 10
+      },
+      {
+        name: "build",
+        cmd: "python -m build",
+        detectFile: "pyproject.toml",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["pytest.ini", "pyproject.toml", "setup.cfg", "conftest.py"],
+    frameworks: [
+      { name: "pytest", detect: "pytest.ini", cmd: "pytest", priority: 10 },
+      {
+        name: "unittest",
+        detect: "setup.py",
+        cmd: "python -m unittest discover",
+        priority: 8
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["pyproject.toml", ".ruff.toml", "setup.cfg"],
+    linters: [
+      {
+        name: "ruff",
+        detect: "pyproject.toml",
+        cmd: "ruff check --fix .",
+        priority: 10
+      },
+      { name: "flake8", detect: "setup.cfg", cmd: "flake8 .", priority: 8 }
+    ]
+  },
+  audit: {
+    detectFiles: ["requirements.txt", "Pipfile.lock", "pyproject.toml"],
+    command: "pip-audit --format json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "python", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Use type annotations on all function signatures (PEP 484)",
+      "Prefer f-strings over .format() or % formatting",
+      "Use pathlib.Path over os.path for filesystem operations",
+      "Never use bare except:; catch specific exception types",
+      "Follow PEP 8 style; max line length 120 characters"
+    ],
+    reviewerChecklist: [
+      "Verify type annotations are present on all public functions",
+      "Check for bare except clauses or overly broad exception handling",
+      "Confirm no mutable default arguments (def f(x=[]) anti-pattern)",
+      "Validate f-string usage and no format string injection risks",
+      "Check imports are organized (stdlib \u2192 third-party \u2192 local)"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "rust",
+  displayName: "Rust",
+  tier: 1,
+  extensions: [".rs"],
+  treeSitter: {
+    grammarId: "rust",
+    wasmFile: "tree-sitter-rust.wasm",
+    commentNodes: ["line_comment", "block_comment"]
+  },
+  build: {
+    detectFiles: ["Cargo.toml"],
+    commands: [
+      {
+        name: "cargo build",
+        cmd: "cargo build",
+        detectFile: "Cargo.toml",
+        priority: 10
+      },
+      {
+        name: "cargo check",
+        cmd: "cargo check",
+        detectFile: "Cargo.toml",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["Cargo.toml"],
+    frameworks: [
+      {
+        name: "cargo",
+        detect: "Cargo.toml",
+        cmd: "cargo test",
+        priority: 10
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["Cargo.toml"],
+    linters: [
+      {
+        name: "clippy",
+        detect: "Cargo.toml",
+        cmd: "cargo clippy --fix --allow-dirty",
+        priority: 10
+      },
+      { name: "rustfmt", detect: "Cargo.toml", cmd: "cargo fmt", priority: 9 }
+    ]
+  },
+  audit: {
+    detectFiles: ["Cargo.lock"],
+    command: "cargo audit --json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "rust", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Prefer owned types over references where ownership is clear; use lifetimes sparingly",
+      "Use Result<T, E> and ? operator for error propagation; never unwrap() in library code",
+      "Prefer iterators and combinators over explicit loops",
+      "Derive standard traits (Debug, Clone, PartialEq) whenever sensible",
+      "Avoid unsafe blocks; document any unsafe usage with SAFETY comments"
+    ],
+    reviewerChecklist: [
+      "Verify no unwrap() or expect() calls in library/production paths",
+      "Check for potential panics in indexing, arithmetic overflow, or slice operations",
+      "Confirm error types implement std::error::Error and are propagated correctly",
+      "Validate lifetime annotations are minimal and correct",
+      "Check unsafe blocks have SAFETY comments explaining invariants"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "go",
+  displayName: "Go",
+  tier: 1,
+  extensions: [".go"],
+  treeSitter: {
+    grammarId: "go",
+    wasmFile: "tree-sitter-go.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["go.mod"],
+    commands: [
+      {
+        name: "go build",
+        cmd: "go build ./...",
+        detectFile: "go.mod",
+        priority: 10
+      },
+      {
+        name: "go vet",
+        cmd: "go vet ./...",
+        detectFile: "go.mod",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["go.mod"],
+    frameworks: [
+      { name: "go-test", detect: "go.mod", cmd: "go test ./...", priority: 10 }
+    ]
+  },
+  lint: {
+    detectFiles: ["go.mod", ".golangci.yml", ".golangci.yaml"],
+    linters: [
+      {
+        name: "golangci-lint",
+        detect: ".golangci.yml",
+        cmd: "golangci-lint run --fix",
+        priority: 10
+      },
+      { name: "gofmt", detect: "go.mod", cmd: "gofmt -w .", priority: 9 }
+    ]
+  },
+  audit: {
+    detectFiles: ["go.mod"],
+    command: "govulncheck -json ./...",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "go", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Always check and return errors; never discard error return values",
+      "Use idiomatic Go error wrapping with fmt.Errorf and %w verb",
+      "Prefer table-driven tests; use t.Run for subtests",
+      "Avoid global mutable state; use dependency injection via interfaces",
+      "Use context.Context as first parameter for all I/O-bound functions"
+    ],
+    reviewerChecklist: [
+      "Verify all error return values are checked (no _ = err pattern)",
+      "Check goroutine usage \u2014 confirm no goroutine leaks or missing WaitGroups",
+      "Validate context propagation through call chains",
+      "Confirm exported types/functions have doc comments",
+      "Check for data races in concurrent code (verify sync usage)"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "java",
+  displayName: "Java",
+  tier: 2,
+  extensions: [".java"],
+  treeSitter: {
+    grammarId: "java",
+    wasmFile: "tree-sitter-java.wasm",
+    commentNodes: ["line_comment", "block_comment"]
+  },
+  build: {
+    detectFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    commands: [
+      {
+        name: "maven",
+        cmd: "mvn compile -q",
+        detectFile: "pom.xml",
+        priority: 10
+      },
+      {
+        name: "gradle",
+        cmd: "gradle build -q",
+        detectFile: "build.gradle",
+        priority: 9
+      },
+      {
+        name: "gradle-kts",
+        cmd: "gradle build -q",
+        detectFile: "build.gradle.kts",
+        priority: 8
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    frameworks: [
+      {
+        name: "maven",
+        detect: "pom.xml",
+        cmd: "mvn test -q",
+        priority: 10
+      },
+      {
+        name: "gradle",
+        detect: "build.gradle",
+        cmd: "gradle test -q",
+        priority: 9
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["checkstyle.xml", "pom.xml"],
+    linters: [
+      {
+        name: "checkstyle",
+        detect: "checkstyle.xml",
+        cmd: "mvn checkstyle:check",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["pom.xml", "build.gradle"],
+    command: null,
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "java", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Use checked exceptions for recoverable conditions; unchecked for programming errors",
+      "Prefer composition over inheritance; favor interfaces over abstract classes",
+      "Use Optional<T> for nullable return values rather than returning null",
+      "Follow Java naming conventions: PascalCase classes, camelCase methods/fields",
+      "Close resources in try-with-resources blocks; never rely on finalizers"
+    ],
+    reviewerChecklist: [
+      "Check for unclosed resources \u2014 verify try-with-resources or explicit close()",
+      "Verify null checks are present for all external/injected dependencies",
+      "Confirm thread safety for shared mutable state (synchronized, volatile, atomic)",
+      "Validate exception handling \u2014 no swallowed exceptions or empty catch blocks",
+      "Check for proper equals()/hashCode() overrides on value objects"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "kotlin",
+  displayName: "Kotlin",
+  tier: 2,
+  extensions: [".kt", ".kts"],
+  treeSitter: {
+    grammarId: "kotlin",
+    wasmFile: "tree-sitter-kotlin.wasm",
+    commentNodes: ["line_comment", "multiline_comment"]
+  },
+  build: {
+    detectFiles: ["build.gradle.kts", "build.gradle", "pom.xml"],
+    commands: [
+      {
+        name: "gradle-kts",
+        cmd: "gradle build -q",
+        detectFile: "build.gradle.kts",
+        priority: 10
+      },
+      {
+        name: "gradle",
+        cmd: "gradle build -q",
+        detectFile: "build.gradle",
+        priority: 9
+      },
+      {
+        name: "maven",
+        cmd: "mvn compile -q",
+        detectFile: "pom.xml",
+        priority: 8
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["build.gradle.kts", "build.gradle"],
+    frameworks: [
+      {
+        name: "gradle",
+        detect: "build.gradle.kts",
+        cmd: "gradle test -q",
+        priority: 10
+      },
+      {
+        name: "gradle",
+        detect: "build.gradle",
+        cmd: "gradle test -q",
+        priority: 9
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["build.gradle.kts", "build.gradle"],
+    linters: [
+      {
+        name: "ktlint",
+        detect: "build.gradle.kts",
+        cmd: "ktlint --format",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["build.gradle.kts", "build.gradle"],
+    command: null,
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: null, semgrepSupport: "beta" },
+  prompts: {
+    coderConstraints: [
+      "Prefer val over var; use data classes for value objects",
+      "Use Kotlin coroutines for async operations; avoid blocking calls on Dispatchers.Main",
+      "Leverage extension functions instead of utility classes",
+      "Use sealed classes for exhaustive when expressions",
+      "Avoid platform types; always declare explicit nullability in API surfaces"
+    ],
+    reviewerChecklist: [
+      "Verify no non-null assertions (!!) in production code without justification",
+      "Check coroutine scope lifecycle \u2014 confirm scopes are cancelled when no longer needed",
+      "Validate when expressions are exhaustive (sealed class coverage)",
+      "Confirm data class equals/hashCode/copy semantics are appropriate",
+      "Check for blocking I/O on the wrong coroutine dispatcher"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "csharp",
+  displayName: "C# / .NET",
+  tier: 2,
+  extensions: [".cs", ".csx"],
+  treeSitter: {
+    grammarId: "csharp",
+    wasmFile: "tree-sitter-c-sharp.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["*.csproj", "*.sln", "Directory.Build.props"],
+    commands: [
+      {
+        name: "dotnet build",
+        cmd: "dotnet build -v quiet",
+        detectFile: "*.csproj",
+        priority: 10
+      },
+      {
+        name: "dotnet build sln",
+        cmd: "dotnet build -v quiet",
+        detectFile: "*.sln",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["*.csproj", "*.sln"],
+    frameworks: [
+      {
+        name: "dotnet-test",
+        detect: "*.csproj",
+        cmd: "dotnet test",
+        priority: 10
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["*.csproj", ".editorconfig"],
+    linters: [
+      {
+        name: "dotnet-format",
+        detect: "*.csproj",
+        cmd: "dotnet format",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["*.csproj", "packages.lock.json"],
+    command: "dotnet list package --vulnerable --include-transitive",
+    outputFormat: "text"
+  },
+  sast: { nativeRuleSet: "csharp", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Use async/await throughout; avoid .Result or .Wait() which can deadlock",
+      "Prefer records for immutable value types; use struct only for small value types",
+      "Use nullable reference types (NRT) \u2014 enable <Nullable>enable</Nullable>",
+      "Dispose IDisposable resources with using statements or declarations",
+      "Follow C# naming conventions: PascalCase for public members, _camelCase for private fields"
+    ],
+    reviewerChecklist: [
+      "Verify no .Result or .Wait() calls that could cause deadlocks",
+      "Check all IDisposable are properly disposed (using / IAsyncDisposable)",
+      "Confirm nullable reference type annotations are present and correct",
+      "Validate LINQ queries do not cause N+1 query patterns in EF contexts",
+      "Check for missing ConfigureAwait(false) in library code"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "cpp",
+  displayName: "C / C++",
+  tier: 2,
+  extensions: [".c", ".h", ".cpp", ".hpp", ".cc", ".cxx"],
+  treeSitter: {
+    grammarId: "cpp",
+    wasmFile: "tree-sitter-cpp.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["CMakeLists.txt", "Makefile", "meson.build"],
+    commands: [
+      {
+        name: "cmake",
+        cmd: "cmake --build build",
+        detectFile: "CMakeLists.txt",
+        priority: 10
+      },
+      { name: "make", cmd: "make", detectFile: "Makefile", priority: 9 },
+      {
+        name: "meson",
+        cmd: "meson compile -C builddir",
+        detectFile: "meson.build",
+        priority: 8
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["CMakeLists.txt"],
+    frameworks: [
+      {
+        name: "ctest",
+        detect: "CMakeLists.txt",
+        cmd: "ctest --test-dir build",
+        priority: 10
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [".clang-tidy", "CMakeLists.txt"],
+    linters: [
+      {
+        name: "cppcheck",
+        detect: "CMakeLists.txt",
+        cmd: "cppcheck --error-exitcode=1 .",
+        priority: 10
+      },
+      {
+        name: "clang-tidy",
+        detect: ".clang-tidy",
+        cmd: "clang-tidy -p build",
+        priority: 9
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["CMakeLists.txt", "vcpkg.json", "conanfile.txt"],
+    command: null,
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "cpp", semgrepSupport: "experimental" },
+  prompts: {
+    coderConstraints: [
+      "Prefer RAII and smart pointers (unique_ptr, shared_ptr) over raw pointers",
+      "Use const-correctness throughout; mark all non-mutating methods const",
+      "Avoid undefined behaviour: no out-of-bounds access, no use-after-free",
+      "Initialize all variables; prefer in-class initializers for member variables",
+      "Use std::array or std::vector instead of C-style arrays"
+    ],
+    reviewerChecklist: [
+      "Verify no raw owning pointers; confirm smart pointer ownership semantics",
+      "Check for memory leaks \u2014 every new has a corresponding delete or smart pointer",
+      "Validate bounds checking on all array/buffer accesses",
+      "Confirm no undefined behavior patterns (signed overflow, strict aliasing violations)",
+      "Check thread safety for shared data (mutex, atomic, lock-free patterns)"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "swift",
+  displayName: "Swift",
+  tier: 2,
+  extensions: [".swift"],
+  treeSitter: {
+    grammarId: "swift",
+    wasmFile: "tree-sitter-swift.wasm",
+    commentNodes: ["comment", "multiline_comment"]
+  },
+  build: {
+    detectFiles: ["Package.swift", "*.xcodeproj", "*.xcworkspace"],
+    commands: [
+      {
+        name: "swift build",
+        cmd: "swift build",
+        detectFile: "Package.swift",
+        priority: 10
+      },
+      {
+        name: "xcodebuild",
+        cmd: "xcodebuild build -quiet",
+        detectFile: "*.xcodeproj",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["Package.swift", "*.xcodeproj"],
+    frameworks: [
+      {
+        name: "swift-test",
+        detect: "Package.swift",
+        cmd: "swift test",
+        priority: 10
+      },
+      {
+        name: "xcodebuild-test",
+        detect: "*.xcodeproj",
+        cmd: "xcodebuild test -quiet",
+        priority: 9
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [".swiftlint.yml", "Package.swift"],
+    linters: [
+      {
+        name: "swiftlint",
+        detect: ".swiftlint.yml",
+        cmd: "swiftlint --fix",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["Package.resolved", "Package.swift"],
+    command: null,
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: null, semgrepSupport: "experimental" },
+  prompts: {
+    coderConstraints: [
+      "Prefer value types (structs, enums) over classes; use classes only for reference semantics",
+      "Use Swift concurrency (async/await, actors) over GCD for new code",
+      "Avoid force unwrap (!) and force cast (as!); use guard let or if let",
+      "Use Swift Package Manager for dependencies where possible",
+      "Mark types and methods as final when subclassing is not intended"
+    ],
+    reviewerChecklist: [
+      "Verify no force unwraps (!) or force casts (as!) in production code",
+      "Check for retain cycles in closures \u2014 confirm [weak self] where needed",
+      "Validate Swift concurrency usage \u2014 no data races across actor boundaries",
+      "Confirm proper error handling with do-try-catch or Result<T,E>",
+      "Check value vs reference type choice is appropriate for the use case"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "dart",
+  displayName: "Dart / Flutter",
+  tier: 3,
+  extensions: [".dart"],
+  treeSitter: {
+    grammarId: "dart",
+    wasmFile: "tree-sitter-dart.wasm",
+    commentNodes: ["comment", "documentation_comment"]
+  },
+  build: {
+    detectFiles: ["pubspec.yaml"],
+    commands: [
+      {
+        name: "flutter build",
+        cmd: "flutter build apk",
+        detectFile: "pubspec.yaml",
+        priority: 10
+      },
+      {
+        name: "dart compile",
+        cmd: "dart compile exe .",
+        detectFile: "pubspec.yaml",
+        priority: 9
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["pubspec.yaml"],
+    frameworks: [
+      {
+        name: "flutter test",
+        detect: "pubspec.yaml",
+        cmd: "flutter test",
+        priority: 10
+      },
+      {
+        name: "dart test",
+        detect: "pubspec.yaml",
+        cmd: "dart test",
+        priority: 9
+      }
+    ]
+  },
+  lint: {
+    detectFiles: ["analysis_options.yaml", "pubspec.yaml"],
+    linters: [
+      {
+        name: "dart analyze",
+        detect: "pubspec.yaml",
+        cmd: "dart analyze",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["pubspec.yaml", "pubspec.lock"],
+    command: "dart pub outdated --json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: null, semgrepSupport: "none" },
+  prompts: {
+    coderConstraints: [
+      "Use null safety features \u2014 prefer late, required, and ? annotations over dynamic",
+      "Follow Dart effective style: lowerCamelCase for variables, UpperCamelCase for types",
+      "Prefer const constructors where possible for performance",
+      "Use async/await over raw Future callbacks",
+      "Separate business logic from UI widgets; use BLoC or Provider patterns"
+    ],
+    reviewerChecklist: [
+      "Verify null safety annotations are correct (no unnecessary ?)",
+      "Check that const constructors are used where the widget tree is static",
+      "Confirm async operations handle error states (catchError or try-catch)",
+      "Validate no direct UI state mutation outside setState or stream",
+      "Check for platform-specific code isolation (dart:io vs dart:html)"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "ruby",
+  displayName: "Ruby",
+  tier: 3,
+  extensions: [".rb", ".rake", ".gemspec"],
+  treeSitter: {
+    grammarId: "ruby",
+    wasmFile: "tree-sitter-ruby.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["Gemfile", "Rakefile"],
+    commands: [
+      {
+        name: "bundle install",
+        cmd: "bundle install",
+        detectFile: "Gemfile",
+        priority: 10
+      },
+      { name: "rake", cmd: "rake", detectFile: "Rakefile", priority: 9 }
+    ]
+  },
+  test: {
+    detectFiles: ["Gemfile", ".rspec", "spec/spec_helper.rb"],
+    frameworks: [
+      {
+        name: "rspec",
+        detect: ".rspec",
+        cmd: "bundle exec rspec",
+        priority: 10
+      },
+      {
+        name: "minitest",
+        detect: "Rakefile",
+        cmd: "bundle exec rake test",
+        priority: 9
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [".rubocop.yml", "Gemfile"],
+    linters: [
+      {
+        name: "rubocop",
+        detect: ".rubocop.yml",
+        cmd: "rubocop --autocorrect",
+        priority: 10
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["Gemfile.lock"],
+    command: "bundle-audit check --format json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: null, semgrepSupport: "experimental" },
+  prompts: {
+    coderConstraints: [
+      "Follow Ruby community style (Rubocop defaults); 120-char line limit",
+      "Prefer symbols over strings for hash keys",
+      "Use frozen_string_literal: true magic comment in all files",
+      "Avoid monkey-patching core classes; prefer refinements",
+      "Use keyword arguments for methods with more than 2 parameters"
+    ],
+    reviewerChecklist: [
+      "Verify frozen_string_literal comment is present in new files",
+      "Check for N+1 query patterns in ActiveRecord code",
+      "Validate no eval or send with user-controlled input (code injection risk)",
+      "Confirm exception handling is specific \u2014 no bare rescue",
+      "Check for missing validations on ActiveRecord models"
+    ]
+  }
+});
+LANGUAGE_REGISTRY.register({
+  id: "php",
+  displayName: "PHP",
+  tier: 3,
+  extensions: [".php", ".phtml", ".blade.php"],
+  treeSitter: {
+    grammarId: "php",
+    wasmFile: "tree-sitter-php.wasm",
+    commentNodes: ["comment"]
+  },
+  build: {
+    detectFiles: ["composer.json"],
+    commands: [
+      {
+        name: "Composer Install",
+        cmd: "composer install --no-interaction --prefer-dist",
+        detectFile: "composer.json",
+        priority: 10
+      }
+    ]
+  },
+  test: {
+    detectFiles: ["Pest.php", "phpunit.xml", "phpunit.xml.dist"],
+    frameworks: [
+      {
+        name: "Pest",
+        detect: "Pest.php",
+        cmd: "vendor/bin/pest",
+        priority: 10
+      },
+      {
+        name: "PHPUnit",
+        detect: "phpunit.xml",
+        cmd: "vendor/bin/phpunit",
+        priority: 8
+      },
+      {
+        name: "PHPUnit",
+        detect: "phpunit.xml.dist",
+        cmd: "vendor/bin/phpunit",
+        priority: 7
+      }
+    ]
+  },
+  lint: {
+    detectFiles: [
+      "phpstan.neon",
+      "phpstan.neon.dist",
+      "pint.json",
+      ".php-cs-fixer.php",
+      "phpcs.xml"
+    ],
+    linters: [
+      {
+        name: "PHPStan",
+        detect: "phpstan.neon",
+        cmd: "vendor/bin/phpstan analyse",
+        priority: 10
+      },
+      {
+        name: "PHPStan",
+        detect: "phpstan.neon.dist",
+        cmd: "vendor/bin/phpstan analyse",
+        priority: 9
+      },
+      {
+        name: "Pint",
+        detect: "pint.json",
+        cmd: "vendor/bin/pint --test",
+        priority: 8
+      },
+      {
+        name: "PHP-CS-Fixer",
+        detect: ".php-cs-fixer.php",
+        cmd: "vendor/bin/php-cs-fixer fix --dry-run --diff",
+        priority: 7
+      }
+    ]
+  },
+  audit: {
+    detectFiles: ["composer.lock"],
+    command: "composer audit --locked --format=json",
+    outputFormat: "json"
+  },
+  sast: { nativeRuleSet: "php", semgrepSupport: "ga" },
+  prompts: {
+    coderConstraints: [
+      "Follow PSR-12 coding standards",
+      "Use strict types declaration: declare(strict_types=1)",
+      "Prefer type hints and return type declarations on all functions",
+      "Use dependency injection over static methods and singletons",
+      "Prefer named constructors and value objects over primitive obsession"
+    ],
+    reviewerChecklist: [
+      "Verify no user input reaches SQL queries without parameterised binding",
+      "Check for XSS \u2014 all output must be escaped with htmlspecialchars()",
+      "Confirm no eval(), exec(), or shell_exec() with user-controlled input",
+      "Validate proper error handling \u2014 no bare catch blocks that swallow errors",
+      "Challenge any PHP/Laravel documentation or README claim that exceeds what is implemented and CI-verified in v6.49.0 (composer build, PHPUnit/Pest/artisan test, Pint/PHP-CS-Fixer lint, PHPStan static analysis, composer audit, Laravel detection, Blade scanning, 3 Laravel SAST rules). If a PR adds docs claiming broader support, verify it is backed by tests."
+    ],
+    testConstraints: [
+      "Prefer feature tests for HTTP, middleware, and authentication flows \u2014 use Laravel RefreshDatabase or DatabaseTransactions traits",
+      "Use unit tests for isolated business logic classes that do not require the full Laravel application container",
+      "Pest and PHPUnit coexist in many Laravel repos \u2014 php artisan test runs both; do not assume PHPUnit-only",
+      "Use .env.testing for test environment configuration; run php artisan config:clear when environment changes affect tests",
+      "For database tests, prefer RefreshDatabase over manual setUp/tearDown to avoid state leakage between tests",
+      "Run php artisan config:clear and php artisan cache:clear before running tests if environment variables changed",
+      "Use separate .env.testing file for test-specific configuration; never rely on .env for CI test runs",
+      "For parallel testing with php artisan test --parallel, ensure database connections use separate databases per worker (APP_ENV=testing + test database suffix pattern)"
+    ]
+  }
+});
+
+// src/lang/detector.ts
+function getProfileForFile(filePath) {
+  const ext = extname(filePath);
+  if (!ext)
+    return;
+  return LANGUAGE_REGISTRY.getByExtension(ext);
+}
+async function detectProjectLanguages(projectDir) {
+  const detected = new Set;
+  async function scanDir(dir) {
+    let dirEntries;
+    let entries;
+    try {
+      dirEntries = await readdir(dir, { withFileTypes: true });
+      entries = dirEntries.map((e) => e.name);
+    } catch {
+      return;
+    }
+    for (const profile of LANGUAGE_REGISTRY.getAll()) {
+      for (const detectFile of profile.build.detectFiles) {
+        if (detectFile.includes("*") || detectFile.includes("?")) {
+          const regex = new RegExp(`^${detectFile.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+          if (dirEntries.some((e) => !e.isDirectory() && regex.test(e.name))) {
+            detected.add(profile.id);
+            break;
+          }
+          continue;
+        }
+        try {
+          await access(join(dir, detectFile));
+          detected.add(profile.id);
+          break;
+        } catch {}
+      }
+    }
+    for (const entry of entries) {
+      const ext = extname(entry);
+      if (!ext)
+        continue;
+      const profile = LANGUAGE_REGISTRY.getByExtension(ext);
+      if (profile) {
+        detected.add(profile.id);
+      }
+    }
+  }
+  await scanDir(projectDir);
+  try {
+    const topEntries = await readdir(projectDir, { withFileTypes: true });
+    for (const entry of topEntries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        await scanDir(join(projectDir, entry.name));
+      }
+    }
+  } catch {}
+  const result = [];
+  for (const id of detected) {
+    const profile = LANGUAGE_REGISTRY.getById(id);
+    if (profile)
+      result.push(profile);
+  }
+  result.sort((a, b) => a.tier - b.tier);
+  return result;
+}
+
+// src/lang/default-backend.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/build/command-resolution.ts
+import * as fs from "fs";
+import * as path from "path";
+var WINDOWS_LOCAL_SHIM_CANDIDATES = [
+  { suffix: ".cmd", requiresNode: true },
+  { suffix: ".exe", requiresNode: false },
+  { suffix: ".bat", requiresNode: true },
+  { suffix: ".ps1", requiresNode: true },
+  { suffix: "", requiresNode: true }
+];
+function tokenizeCommand(command) {
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (const ch of command.trim()) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        buf += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === " " || ch === "\t") {
+      if (buf.length > 0) {
+        out.push(buf);
+        buf = "";
+      }
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.length > 0)
+    out.push(buf);
+  return out;
+}
+function findCommandSuffixStart(command) {
+  let quote = null;
+  let sawTokenChar = false;
+  for (let i = 0;i < command.length; i++) {
+    const ch = command[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        sawTokenChar = true;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      sawTokenChar = true;
+      continue;
+    }
+    if ((ch === " " || ch === "\t") && sawTokenChar) {
+      return i;
+    }
+    if (ch !== " " && ch !== "\t") {
+      sawTokenChar = true;
+    }
+  }
+  return command.length;
+}
+function resolveLocalCandidate(binary, workingDir, platform = process.platform, isAvailable) {
+  const candidates = platform === "win32" ? WINDOWS_LOCAL_SHIM_CANDIDATES : [{ suffix: "", requiresNode: true }];
+  for (const candidate of candidates) {
+    const executable = `${binary}${candidate.suffix}`;
+    const absolute = path.join(workingDir, "node_modules", ".bin", executable);
+    if (!fs.existsSync(absolute))
+      continue;
+    if (candidate.requiresNode && isAvailable && !isAvailable("node"))
+      continue;
+    const relative = platform === "win32" ? path.win32.join("node_modules", ".bin", executable) : path.posix.join("node_modules", ".bin", executable);
+    return {
+      absolute,
+      relative,
+      requiresNode: candidate.requiresNode
+    };
+  }
+  return null;
+}
+function hasAnyLocalCandidate(binary, workingDir, platform = process.platform) {
+  const candidates = platform === "win32" ? WINDOWS_LOCAL_SHIM_CANDIDATES : [{ suffix: "", requiresNode: true }];
+  for (const candidate of candidates) {
+    const executable = `${binary}${candidate.suffix}`;
+    if (fs.existsSync(path.join(workingDir, "node_modules", ".bin", executable))) {
+      return true;
+    }
+  }
+  return false;
+}
+function resolveLocalCommand(command, workingDir, isAvailable, platform = process.platform) {
+  const tokens = tokenizeCommand(command);
+  if (tokens.length === 0)
+    return null;
+  const [binary, ...args] = tokens;
+  if (["npx", "bunx", "pnpx"].includes(binary))
+    return null;
+  if (binary.includes("/") || binary.includes("\\"))
+    return null;
+  const trimmed = command.trim();
+  const local = resolveLocalCandidate(binary, workingDir, platform, isAvailable);
+  if (local) {
+    const shellPath = platform === "win32" ? local.relative : `./${local.relative}`;
+    return {
+      argv: [local.absolute, ...args],
+      shellCommand: `${shellPath}${trimmed.slice(findCommandSuffixStart(trimmed))}`
+    };
+  }
+  if (hasAnyLocalCandidate(binary, workingDir, platform))
+    return null;
+  return isAvailable(binary) ? { argv: tokens, shellCommand: command } : null;
+}
+function resolveLocalNodeTool(tool2, args, workingDir, platform = process.platform, isAvailable) {
+  const local = resolveLocalCandidate(tool2, workingDir, platform, platform === "win32" ? isAvailable : undefined);
+  if (local)
+    return [local.absolute, ...args];
+  if (hasAnyLocalCandidate(tool2, workingDir, platform))
+    return null;
+  return isAvailable?.(tool2) ? [tool2, ...args] : null;
+}
+
+// src/build/discovery.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var SUPPORTED_NODE_PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"];
+var MAX_PACKAGE_MANAGER_EVIDENCE_CHARS = 120;
+var ECOSYSTEMS = [
+  {
+    ecosystem: "node",
+    buildFiles: ["package.json"],
+    toolchainCommands: [...SUPPORTED_NODE_PACKAGE_MANAGERS],
+    commands: [
+      { command: "npm run build", priority: 30 },
+      { command: "npm run typecheck", priority: 20 },
+      { command: "npm run check", priority: 10 }
+    ],
+    repoDefinedScripts: ["build", "typecheck", "check", "compile"]
+  },
+  {
+    ecosystem: "rust",
+    buildFiles: ["Cargo.toml"],
+    toolchainCommands: ["cargo"],
+    commands: [
+      { command: "cargo build", priority: 20 },
+      { command: "cargo check", priority: 10 }
+    ]
+  },
+  {
+    ecosystem: "go",
+    buildFiles: ["go.mod"],
+    toolchainCommands: ["go"],
+    commands: [{ command: "go build ./...", priority: 10 }]
+  },
+  {
+    ecosystem: "python",
+    buildFiles: ["pyproject.toml", "setup.py", "setup.cfg"],
+    toolchainCommands: ["python", "python3", "py"],
+    commands: [
+      { command: "python -m build", priority: 20 },
+      { command: "python -m py_compile", priority: 10 }
+    ]
+  },
+  {
+    ecosystem: "java-maven",
+    buildFiles: ["pom.xml"],
+    toolchainCommands: ["mvn"],
+    commands: [{ command: "mvn compile", priority: 10 }]
+  },
+  {
+    ecosystem: "java-gradle",
+    buildFiles: ["build.gradle", "build.gradle.kts", "gradle.properties"],
+    toolchainCommands: ["gradle", "gradlew"],
+    commands: [
+      {
+        command: process.platform === "win32" ? "gradlew.bat build" : "./gradlew build",
+        priority: 20
+      },
+      { command: "gradle build", priority: 10 }
+    ]
+  },
+  {
+    ecosystem: "dotnet",
+    buildFiles: ["*.csproj", "*.fsproj", "*.vbproj"],
+    toolchainCommands: ["dotnet"],
+    commands: [{ command: "dotnet build", priority: 10 }]
+  },
+  {
+    ecosystem: "swift",
+    buildFiles: ["Package.swift"],
+    toolchainCommands: ["swift"],
+    commands: [{ command: "swift build", priority: 10 }]
+  },
+  {
+    ecosystem: "dart",
+    buildFiles: ["pubspec.yaml", "pubspec.lock"],
+    toolchainCommands: ["dart", "flutter"],
+    commands: [
+      { command: "dart compile", priority: 20 },
+      { command: "dart analyze", priority: 10 }
+    ]
+  },
+  {
+    ecosystem: "cpp",
+    buildFiles: ["Makefile", "CMakeLists.txt"],
+    toolchainCommands: ["make", "cmake"],
+    commands: [
+      { command: "make", priority: 20 },
+      { command: "cmake -B build && cmake --build build", priority: 10 }
+    ]
+  },
+  {
+    ecosystem: "php-composer",
+    buildFiles: ["composer.json"],
+    toolchainCommands: ["composer"],
+    commands: [
+      {
+        command: "composer install --no-interaction --prefer-dist",
+        priority: 10
+      }
+    ]
+  }
+];
+var PROFILE_TO_ECOSYSTEM_NAMES = {
+  typescript: ["node"],
+  javascript: ["node"],
+  python: ["python"],
+  rust: ["rust"],
+  go: ["go"],
+  java: ["java-maven", "java-gradle"],
+  kotlin: ["java-gradle"],
+  csharp: ["dotnet"],
+  cpp: ["cpp"],
+  swift: ["swift"],
+  dart: ["dart"],
+  ruby: [],
+  php: ["php-composer"]
+};
+var toolchainCache = new Map;
+var IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000;
+function isCommandAvailable(command) {
+  if (toolchainCache.has(command)) {
+    return toolchainCache.get(command);
+  }
+  const isWindows = process.platform === "win32";
+  try {
+    const searchName = isWindows ? command : command;
+    const result = _internals.spawnSyncImpl(isWindows ? ["where", searchName] : ["which", searchName], {
+      cwd: process.cwd(),
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      timeout: IS_COMMAND_AVAILABLE_TIMEOUT_MS
+    });
+    const available = result.success;
+    toolchainCache.set(command, available);
+    return available;
+  } catch {
+    toolchainCache.set(command, false);
+    return false;
+  }
+}
+function checkToolchain(commands) {
+  return commands.some((cmd) => _internals.isCommandAvailable(cmd));
+}
+function findBuildFiles(workingDir, patterns) {
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const dir = workingDir;
+      try {
+        const files = fs2.readdirSync(dir);
+        const regex = simpleGlobToRegex(pattern);
+        const matches = files.filter((f) => regex.test(f));
+        if (matches.length > 0) {
+          return path2.join(dir, matches[0]);
+        }
+      } catch {}
+    } else {
+      const filePath = path2.join(workingDir, pattern);
+      if (fs2.existsSync(filePath)) {
+        return filePath;
+      }
+    }
+  }
+  return null;
+}
+function sanitizeEvidenceText(raw, maxChars) {
+  let withoutControls = "";
+  for (const char of raw) {
+    const code = char.charCodeAt(0);
+    withoutControls += code < 32 || code === 127 ? " " : char;
+  }
+  const normalized = withoutControls.replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "(empty)";
+  if (normalized.length <= maxChars)
+    return normalized;
+  if (maxChars <= 3)
+    return normalized.slice(0, maxChars);
+  return `${normalized.slice(0, maxChars - 3)}...`;
+}
+function sanitizeRequiredCommand(command) {
+  const sanitized = sanitizeEvidenceText(command, 40);
+  return sanitized === "(empty)" ? null : sanitized;
+}
+function getBinaryFromCommand(command) {
+  return command.trim().split(/\s+/)[0] ?? "";
+}
+function getProfileRequiredCommands(commands) {
+  const uniqueCommands = new Set;
+  for (const command of commands) {
+    const binary = sanitizeRequiredCommand(getBinaryFromCommand(command.cmd));
+    if (binary)
+      uniqueCommands.add(binary);
+  }
+  return Array.from(uniqueCommands);
+}
+function getNoMatchingBuildFilesReason(profileId, commands) {
+  const detectFiles = Array.from(new Set(commands.map((command) => command.detectFile?.trim()).filter((detectFile) => Boolean(detectFile))));
+  if (detectFiles.length === 0) {
+    return `No matching build files for profile ${profileId}`;
+  }
+  return `No matching build files for profile ${profileId}: expected ${detectFiles.join(" or ")}`;
+}
+function getRepoDefinedScripts(workingDir, scripts) {
+  const packageJsonPath = path2.join(workingDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return { commands: [], hasScripts: false };
+  }
+  try {
+    const content = fs2.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (!pkg.scripts || typeof pkg.scripts !== "object") {
+      return { commands: [], hasScripts: false };
+    }
+    const scriptNames = scripts.filter((name) => typeof pkg.scripts[name] === "string" && pkg.scripts[name].trim());
+    if (scriptNames.length === 0)
+      return { commands: [], hasScripts: false };
+    const rawPackageManager = typeof pkg.packageManager === "string" ? pkg.packageManager.trim() : undefined;
+    const declared = rawPackageManager?.split("@")[0]?.trim();
+    const supported = [...SUPPORTED_NODE_PACKAGE_MANAGERS];
+    const sanitizedDeclared = declared ? sanitizeRequiredCommand(declared) : null;
+    const candidates = declared ? [declared] : supported;
+    if (rawPackageManager !== undefined && (!declared || !supported.includes(declared))) {
+      return {
+        commands: [],
+        hasScripts: true,
+        skip: {
+          ecosystem: "node",
+          code: "environment_unavailable",
+          required_commands: sanitizedDeclared ? [sanitizedDeclared] : [],
+          reason: `Unsupported packageManager: ${sanitizeEvidenceText(rawPackageManager, MAX_PACKAGE_MANAGER_EVIDENCE_CHARS)}`
+        }
+      };
+    }
+    const manager = candidates.find((candidate) => _internals.isCommandAvailable(candidate));
+    if (!manager) {
+      return {
+        commands: [],
+        hasScripts: true,
+        skip: {
+          ecosystem: "node",
+          code: "environment_unavailable",
+          required_commands: candidates,
+          reason: `Package manager not available: ${candidates.join(" or ")}`
+        }
+      };
+    }
+    return {
+      hasScripts: true,
+      commands: scriptNames.map((scriptName) => ({
+        command: `${manager} run ${scriptName}`,
+        priority: 100
+      }))
+    };
+  } catch {
+    return { commands: [], hasScripts: false };
+  }
+}
+function filterByScope(workingDir, scope, changedFiles) {
+  if (scope === "all") {
+    return findAllBuildFiles(workingDir);
+  }
+  if (!changedFiles || changedFiles.length === 0) {
+    return [];
+  }
+  return changedFiles;
+}
+function findAllBuildFiles(workingDir) {
+  const allBuildFiles = new Set;
+  for (const ecosystem of ECOSYSTEMS) {
+    for (const pattern of ecosystem.buildFiles) {
+      if (pattern.includes("*")) {
+        const regex = simpleGlobToRegex(pattern);
+        findFilesRecursive(workingDir, regex, allBuildFiles);
+      } else {
+        const filePath = path2.join(workingDir, pattern);
+        if (fs2.existsSync(filePath)) {
+          allBuildFiles.add(filePath);
+        }
+      }
+    }
+  }
+  return Array.from(allBuildFiles);
+}
+function findFilesRecursive(dir, regex, results) {
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
+        findFilesRecursive(fullPath, regex, results);
+      } else if (entry.isFile() && regex.test(entry.name)) {
+        results.add(fullPath);
+      }
+    }
+  } catch {}
+}
+var _internals = {
+  isCommandAvailable,
+  discoverBuildCommandsFromProfiles,
+  discoverBuildCommands,
+  clearToolchainCache,
+  getEcosystems,
+  detectProjectLanguagesImpl: detectProjectLanguages,
+  getLanguageProfileImpl: LANGUAGE_REGISTRY.get.bind(LANGUAGE_REGISTRY),
+  spawnSyncImpl: bunSpawnSync
+};
+async function discoverBuildCommandsFromProfiles(workingDir) {
+  const commands = [];
+  const skipped = [];
+  const detectedProfiles = await _internals.detectProjectLanguagesImpl(workingDir);
+  for (const profile of detectedProfiles) {
+    const fullProfile = _internals.getLanguageProfileImpl(profile.id);
+    if (!fullProfile) {
+      warn(`[build-discovery] profile ${profile.id} not found in registry, skipping`);
+      continue;
+    }
+    const sortedCommands = [...fullProfile.build.commands].sort((a, b) => b.priority - a.priority);
+    const applicableCommands = sortedCommands.filter((cmd) => {
+      if (!cmd.detectFile)
+        return true;
+      const detectFilePath = path2.join(workingDir, cmd.detectFile);
+      return fs2.existsSync(detectFilePath);
+    });
+    if (applicableCommands.length === 0) {
+      skipped.push({
+        ecosystem: fullProfile.id,
+        reason: getNoMatchingBuildFilesReason(fullProfile.id, sortedCommands)
+      });
+      continue;
+    }
+    let foundCommand = false;
+    for (const cmd of applicableCommands) {
+      const resolved = resolveLocalCommand(cmd.cmd, workingDir, _internals.isCommandAvailable);
+      if (resolved) {
+        commands.push({
+          ecosystem: fullProfile.id,
+          command: resolved.shellCommand,
+          cwd: workingDir,
+          priority: cmd.priority
+        });
+        foundCommand = true;
+        break;
+      }
+    }
+    if (!foundCommand) {
+      const requiredCommands = getProfileRequiredCommands(applicableCommands);
+      const triedBinaries = requiredCommands.join(", ");
+      const reason = `No binary available for profile ${fullProfile.id}: tried ${triedBinaries}`;
+      skipped.push({
+        ecosystem: fullProfile.id,
+        code: "environment_unavailable",
+        required_commands: requiredCommands,
+        reason
+      });
+      warn(`[build-discovery] profile ${fullProfile.id}: no binary available, skipping`);
+    }
+  }
+  return { commands, skipped };
+}
+async function discoverBuildCommands(workingDir, options) {
+  const scope = options?.scope ?? "all";
+  const changedFiles = options?.changedFiles ?? [];
+  const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
+  const profileResult = await _internals.discoverBuildCommandsFromProfiles(workingDir);
+  const profileCommands = profileResult.commands;
+  const profileSkipped = profileResult.skipped;
+  const repoDefinedScriptsByEcosystem = new Map;
+  const repoScriptSkips = [];
+  const repoDeclaredEcosystems = new Set;
+  for (const ecosystem of ECOSYSTEMS) {
+    if (!ecosystem.repoDefinedScripts)
+      continue;
+    const repoResult = getRepoDefinedScripts(workingDir, ecosystem.repoDefinedScripts);
+    if (repoResult.commands.length > 0) {
+      repoDefinedScriptsByEcosystem.set(ecosystem.ecosystem, repoResult.commands);
+    }
+    if (repoResult.hasScripts)
+      repoDeclaredEcosystems.add(ecosystem.ecosystem);
+    if (repoResult.skip)
+      repoScriptSkips.push(repoResult.skip);
+  }
+  const filteredProfileCommands = profileCommands.filter((cmd) => {
+    const ecosystemNames = PROFILE_TO_ECOSYSTEM_NAMES[cmd.ecosystem] ?? [];
+    return ecosystemNames.every((name) => !repoDeclaredEcosystems.has(name));
+  });
+  const coveredEcosystems = new Set;
+  for (const cmd of filteredProfileCommands) {
+    const ecosystemNames = PROFILE_TO_ECOSYSTEM_NAMES[cmd.ecosystem] ?? [];
+    for (const name of ecosystemNames) {
+      coveredEcosystems.add(name);
+    }
+  }
+  const commands = [...filteredProfileCommands];
+  const skipped = [...profileSkipped, ...repoScriptSkips];
+  for (const ecosystem of ECOSYSTEMS) {
+    const buildFile = findBuildFiles(workingDir, ecosystem.buildFiles);
+    if (!buildFile)
+      continue;
+    const repoScripts = repoDefinedScriptsByEcosystem.get(ecosystem.ecosystem);
+    if (repoScripts && repoScripts.length > 0) {
+      for (const script of repoScripts) {
+        commands.push({
+          ecosystem: ecosystem.ecosystem,
+          command: script.command,
+          cwd: workingDir,
+          priority: script.priority
+        });
+      }
+      continue;
+    }
+    if (repoDeclaredEcosystems.has(ecosystem.ecosystem)) {
+      continue;
+    }
+    if (coveredEcosystems.has(ecosystem.ecosystem)) {
+      skipped.push({
+        ecosystem: ecosystem.ecosystem,
+        reason: `Covered by profile detection`
+      });
+      continue;
+    }
+    if (!checkToolchain(ecosystem.toolchainCommands)) {
+      skipped.push({
+        ecosystem: ecosystem.ecosystem,
+        code: "environment_unavailable",
+        required_commands: ecosystem.toolchainCommands,
+        reason: `Toolchain not found: ${ecosystem.toolchainCommands.join(" or ")} not on PATH`
+      });
+      continue;
+    }
+    const availableCommands = ecosystem.commands;
+    for (const cmd of availableCommands) {
+      commands.push({
+        ecosystem: ecosystem.ecosystem,
+        command: cmd.command,
+        cwd: workingDir,
+        priority: cmd.priority
+      });
+    }
+  }
+  commands.sort((a, b) => b.priority - a.priority);
+  return { commands, skipped };
+}
+function clearToolchainCache() {
+  toolchainCache.clear();
+}
+function getEcosystems() {
+  return ECOSYSTEMS.map((e) => e.ecosystem);
+}
+var build_discovery = tool({
+  description: "Discover build commands for various ecosystems in a project directory",
+  args: {
+    workingDir: tool.schema.string().describe("Directory to scan for build commands (defaults to current directory)"),
+    scope: tool.schema.string().optional().describe('Scope of detection: "all" for all build files, "changed" for only changed files'),
+    changedFiles: tool.schema.array(tool.schema.string()).optional().describe('List of changed files when scope is "changed"')
+  },
+  async execute(args, _context) {
+    const result = await discoverBuildCommands(args.workingDir, {
+      scope: args.scope ?? "all",
+      changedFiles: args.changedFiles ?? []
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+
+// src/lang/default-backend.ts
+function detectFileExists(dir, pattern) {
+  if (pattern.includes("*") || pattern.includes("?")) {
+    try {
+      const files = fs3.readdirSync(dir);
+      const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+      return files.some((f) => regex.test(f));
+    } catch {
+      return false;
+    }
+  }
+  try {
+    fs3.accessSync(path3.join(dir, pattern));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultSelectTestFramework(profile, dir) {
+  const sorted = [...profile.test.frameworks].sort((a, b) => b.priority - a.priority);
+  for (const fw of sorted) {
+    if (!detectFileExists(dir, fw.detect))
+      continue;
+    const argv = tokenizeCommand(fw.cmd);
+    if (argv.length === 0)
+      continue;
+    if (!isCommandAvailable(argv[0]))
+      continue;
+    return {
+      name: fw.name,
+      cmd: argv,
+      cwd: dir,
+      detectedVia: fw.detect,
+      filesIgnored: false
+    };
+  }
+  return null;
+}
+function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}) {
+  const scope = opts.scope ?? "all";
+  const coverage = opts.coverage ?? false;
+  const bail = opts.bail ?? false;
+  const targets = opts.targets;
+  const nativeTarget = opts.nativeTarget;
+  if (nativeTarget) {
+    if (nativeTarget.framework !== framework)
+      return null;
+    return buildNativeTargetCommand(nativeTarget);
+  }
+  switch (framework) {
+    case "bun": {
+      const args = ["bun", "test"];
+      if (coverage)
+        args.push("--coverage");
+      if (bail)
+        args.push("--bail");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "vitest": {
+      const args = resolveLocalNodeTool("vitest", [
+        "run",
+        "--reporter=json",
+        "--outputFile",
+        ".swarm/cache/test-runner-vitest.json"
+      ], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
+      if (coverage)
+        args.push("--coverage");
+      if (bail)
+        args.push("--bail");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "jest": {
+      const args = resolveLocalNodeTool("jest", ["--json"], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
+      if (coverage)
+        args.push("--coverage");
+      if (bail)
+        args.push("--bail");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "mocha": {
+      const args = resolveLocalNodeTool("mocha", [], dir, process.platform, isCommandAvailable);
+      if (!args)
+        return null;
+      if (bail)
+        args.push("--bail");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "pytest": {
+      const isWindows = process.platform === "win32";
+      const args = isWindows ? ["python", "-m", "pytest"] : ["python3", "-m", "pytest"];
+      if (coverage)
+        args.push("--cov=.", "--cov-report=term-missing");
+      if (bail)
+        args.push("-x");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "cargo": {
+      const args = ["cargo", "test"];
+      if (targets && targets.length > 0) {
+        args.push("--", ...targets);
+      } else if (scope !== "all" && files.length > 0) {
+        args.push(...files);
+      }
+      return args;
+    }
+    case "pester": {
+      if (scope !== "all" && files.length > 0) {
+        const escapedFiles = files.map((f) => f.replace(/'/g, "''").replace(/`/g, "``").replace(/\$/g, "`$"));
+        const psCommand = `Invoke-Pester -Path @('${escapedFiles.join("','")}')`;
+        const utf16Bytes = Buffer.from(psCommand, "utf16le");
+        const base64Command = utf16Bytes.toString("base64");
+        return ["pwsh", "-EncodedCommand", base64Command];
+      }
+      return ["pwsh", "-Command", "Invoke-Pester"];
+    }
+    case "go-test": {
+      const args = ["go", "test"];
+      if (targets && targets.length > 0) {
+        args.push("-run", targets.join("|"));
+      }
+      args.push("./...");
+      return args;
+    }
+    case "maven": {
+      const args = ["mvn", "test"];
+      if (targets && targets.length > 0) {
+        args.push(`-Dtest=${targets.join(",")}`);
+      }
+      return args;
+    }
+    case "gradle": {
+      const isWindows = process.platform === "win32";
+      const hasGradlewBat = fs3.existsSync(path3.join(dir, "gradlew.bat"));
+      const hasGradlew = fs3.existsSync(path3.join(dir, "gradlew"));
+      const args = [];
+      if (hasGradlewBat && isWindows)
+        args.push("gradlew.bat");
+      else if (hasGradlew)
+        args.push("./gradlew");
+      else
+        args.push("gradle");
+      args.push("test");
+      if (targets && targets.length > 0) {
+        for (const target of targets) {
+          args.push("--tests", target);
+        }
+      }
+      return args;
+    }
+    case "dotnet-test": {
+      const args = ["dotnet", "test"];
+      if (targets && targets.length > 0) {
+        args.push("--filter", targets.join("|"));
+      }
+      return args;
+    }
+    case "ctest": {
+      const buildDirCandidates = [
+        "build",
+        "_build",
+        "cmake-build-debug",
+        "cmake-build-release",
+        "out"
+      ];
+      const actualBuildDir = buildDirCandidates.find((d) => fs3.existsSync(path3.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const args = ["ctest", "--test-dir", actualBuildDir];
+      if (targets && targets.length > 0) {
+        args.push("-R", targets.join("|"));
+      }
+      return args;
+    }
+    case "swift-test": {
+      const args = ["swift", "test"];
+      if (targets && targets.length > 0) {
+        for (const target of targets) {
+          args.push("--filter", target);
+        }
+      }
+      return args;
+    }
+    case "dart-test":
+      return isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
+    case "rspec": {
+      const args = isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      if (bail)
+        args.push("--fail-fast");
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "minitest":
+      if (scope !== "all" && files.length > 0) {
+        const requires = files.map((f) => `require_relative '${f.replace(/\\/g, "/").replace(/'/g, "\\'")}'`).join("; ");
+        return ["ruby", "-Itest", "-e", requires];
+      }
+      return [
+        "ruby",
+        "-Itest",
+        "-e",
+        'Dir.glob("test/**/*_test.rb").sort.each { |f| require_relative f }'
+      ];
+    case "pest": {
+      const args = [phpVendorBin("pest")];
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "phpunit": {
+      const args = [phpVendorBin("phpunit")];
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    case "php-artisan": {
+      const args = ["php", "artisan", "test"];
+      if (scope !== "all" && files.length > 0)
+        args.push(...files);
+      return args;
+    }
+    default: {
+      const fw = profile.test.frameworks.find((f) => f.name === framework);
+      if (!fw)
+        return null;
+      const argv = tokenizeCommand(fw.cmd);
+      if (argv.length === 0)
+        return null;
+      if (files.length === 0)
+        return argv;
+      return [...argv, ...files];
+    }
+  }
+}
+function escapeRegexLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildNativeTargetCommand(target) {
+  if (target.framework === "ctest") {
+    return [
+      "ctest",
+      "--test-dir",
+      target.path,
+      "-R",
+      `^${escapeRegexLiteral(target.name)}$`
+    ];
+  }
+  const selector = target.name.split("/").map((part) => `^${escapeRegexLiteral(part)}$`).join("/");
+  const packagePath = target.path === "." ? "." : target.path.startsWith("./") ? target.path : `./${target.path.replace(/\\/g, "/")}`;
+  return ["go", "test", "-v", "-run", selector, packagePath];
+}
+function phpVendorBin(name) {
+  return path3.join("vendor", "bin", process.platform === "win32" ? `${name}.bat` : name);
+}
+function defaultParseTestOutput(framework, stdout, stderr, exitCode) {
+  const output = stdout && stderr ? `${stdout}
+${stderr}` : stdout || stderr || "";
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let total;
+  let coveragePercent;
+  switch (framework) {
+    case "vitest":
+    case "jest":
+    case "bun": {
+      const jsonMatch = output.match(/\{[\s\S]*"testResults"[\s\S]*\}/);
+      if (jsonMatch) {
+        try {
+          const parsed = JSON.parse(jsonMatch[0]);
+          if (parsed.numTotalTests !== undefined) {
+            passed = parsed.numPassedTests || 0;
+            failed = parsed.numFailedTests || 0;
+            skipped = parsed.numPendingTests || 0;
+            total = parsed.numTotalTests || 0;
+          }
+          if (parsed.coverage !== undefined) {
+            coveragePercent = parsed.coverage;
+          }
+        } catch {}
+      }
+      if (total === undefined || total === 0) {
+        const passMatch = output.match(/(\d+)\s+pass(ing|ed)?/);
+        const failMatch = output.match(/(\d+)\s+fail(ing|ed)?/);
+        const skipMatch = output.match(/(\d+)\s+skip(ping|ped)?/);
+        if (passMatch)
+          passed = parseInt(passMatch[1], 10);
+        if (failMatch)
+          failed = parseInt(failMatch[1], 10);
+        if (skipMatch)
+          skipped = parseInt(skipMatch[1], 10);
+        total = passed + failed + skipped;
+      }
+      const coverageMatch = output.match(/All files[^\d]*(\d+\.?\d*)\s*%/);
+      if (coveragePercent === undefined && coverageMatch) {
+        coveragePercent = parseFloat(coverageMatch[1]);
+      }
+      break;
+    }
+    case "mocha": {
+      const passMatch = output.match(/(\d+)\s+passing/);
+      const failMatch = output.match(/(\d+)\s+failing/);
+      const pendingMatch = output.match(/(\d+)\s+pending/);
+      if (passMatch)
+        passed = parseInt(passMatch[1], 10);
+      if (failMatch)
+        failed = parseInt(failMatch[1], 10);
+      if (pendingMatch)
+        skipped = parseInt(pendingMatch[1], 10);
+      total = passed + failed + skipped;
+      break;
+    }
+    case "pytest": {
+      const passMatch = output.match(/(\d+)\s+passed/);
+      const failMatch = output.match(/(\d+)\s+failed/);
+      const skipMatch = output.match(/(\d+)\s+skipped/);
+      if (passMatch)
+        passed = parseInt(passMatch[1], 10);
+      if (failMatch)
+        failed = parseInt(failMatch[1], 10);
+      if (skipMatch)
+        skipped = parseInt(skipMatch[1], 10);
+      total = passed + failed + skipped;
+      const coverageMatch = output.match(/TOTAL\s+(\d+\.?\d*)\s*%/);
+      if (coverageMatch)
+        coveragePercent = parseFloat(coverageMatch[1]);
+      break;
+    }
+    case "cargo": {
+      const passMatch = output.match(/test result: ok\. (\d+) passed/);
+      const failMatch = output.match(/test result: FAILED\. (\d+) passed; (\d+) failed/);
+      if (failMatch) {
+        passed = parseInt(failMatch[1], 10);
+        failed = parseInt(failMatch[2], 10);
+      } else if (passMatch) {
+        passed = parseInt(passMatch[1], 10);
+      }
+      total = passed + failed;
+      break;
+    }
+    case "pester": {
+      const passMatch = output.match(/Passed:\s*(\d+)/);
+      const failMatch = output.match(/Failed:\s*(\d+)/);
+      const skipMatch = output.match(/Skipped:\s*(\d+)/);
+      if (passMatch)
+        passed = parseInt(passMatch[1], 10);
+      if (failMatch)
+        failed = parseInt(failMatch[1], 10);
+      if (skipMatch)
+        skipped = parseInt(skipMatch[1], 10);
+      total = passed + failed + skipped;
+      break;
+    }
+    case "go-test": {
+      const passMatches = [...output.matchAll(/--- PASS:/g)];
+      const failMatches = [...output.matchAll(/--- FAIL:/g)];
+      const skipMatches = [...output.matchAll(/--- SKIP:/g)];
+      passed = passMatches.length;
+      failed = failMatches.length;
+      skipped = skipMatches.length;
+      total = passed + failed + skipped;
+      const covMatch = output.match(/coverage:\s*(\d+\.?\d*)\s*%/);
+      if (covMatch)
+        coveragePercent = parseFloat(covMatch[1]);
+      break;
+    }
+    case "maven": {
+      const mavenMatch = output.match(/Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/);
+      if (mavenMatch) {
+        const tot = parseInt(mavenMatch[1], 10);
+        const failures = parseInt(mavenMatch[2], 10);
+        const errors = parseInt(mavenMatch[3], 10);
+        const sk = parseInt(mavenMatch[4], 10);
+        failed = failures + errors;
+        skipped = sk;
+        passed = tot - failed - sk;
+        total = tot;
+      }
+      break;
+    }
+    case "gradle": {
+      const gradleMatch = output.match(/(\d+) tests? completed(?:,\s*(\d+) failed)?(?:,\s*(\d+) skipped)?/);
+      if (gradleMatch) {
+        total = parseInt(gradleMatch[1], 10);
+        failed = gradleMatch[2] ? parseInt(gradleMatch[2], 10) : 0;
+        skipped = gradleMatch[3] ? parseInt(gradleMatch[3], 10) : 0;
+        passed = total - failed - skipped;
+      }
+      break;
+    }
+    case "dotnet-test": {
+      const passMatch = output.match(/Passed[!:]?\s*(\d+)/i);
+      const failMatch = output.match(/Failed[!:]?\s*(\d+)/i);
+      const skipMatch = output.match(/Skipped[!:]?\s*(\d+)/i);
+      if (passMatch)
+        passed = parseInt(passMatch[1], 10);
+      if (failMatch)
+        failed = parseInt(failMatch[1], 10);
+      if (skipMatch)
+        skipped = parseInt(skipMatch[1], 10);
+      total = passed + failed + skipped;
+      break;
+    }
+    case "ctest": {
+      const disabledCount = [
+        ...output.matchAll(/\*{3}Not Run\s+\(Disabled\)/gi)
+      ].length;
+      skipped = disabledCount;
+      const ctestMatch = output.match(/(\d+) tests? failed out of (\d+)/);
+      if (ctestMatch) {
+        failed = parseInt(ctestMatch[1], 10);
+        const executedTotal = parseInt(ctestMatch[2], 10);
+        total = executedTotal + disabledCount;
+        passed = executedTotal - failed;
+      } else {
+        const allPassMatch = output.match(/100% tests passed.*?(\d+) tests?/);
+        if (allPassMatch) {
+          const executedTotal = parseInt(allPassMatch[1], 10);
+          total = executedTotal + disabledCount;
+          passed = executedTotal;
+        } else if (disabledCount > 0) {
+          total = disabledCount;
+        }
+      }
+      break;
+    }
+    case "swift-test": {
+      const swiftMatch = output.match(/Executed (\d+) tests?,\s*with (\d+) failures?/);
+      if (swiftMatch) {
+        total = parseInt(swiftMatch[1], 10);
+        failed = parseInt(swiftMatch[2], 10);
+        passed = total - failed;
+      }
+      break;
+    }
+    case "dart-test": {
+      const dartPassMatch = output.match(/\+(\d+):\s*All tests passed/);
+      const dartMixMatch = output.match(/\+(\d+)\s+-(\d+):/);
+      if (dartPassMatch) {
+        passed = parseInt(dartPassMatch[1], 10);
+        total = passed;
+      } else if (dartMixMatch) {
+        passed = parseInt(dartMixMatch[1], 10);
+        failed = parseInt(dartMixMatch[2], 10);
+        total = passed + failed;
+      }
+      break;
+    }
+    case "rspec": {
+      const rspecMatch = output.match(/(\d+) examples?,\s*(\d+) failures?(?:,\s*(\d+) pending)?/);
+      if (rspecMatch) {
+        total = parseInt(rspecMatch[1], 10);
+        failed = parseInt(rspecMatch[2], 10);
+        skipped = rspecMatch[3] ? parseInt(rspecMatch[3], 10) : 0;
+        passed = total - failed - skipped;
+      }
+      break;
+    }
+    case "minitest": {
+      const minitestMatch = output.match(/(\d+) runs?,\s*\d+ assertions?,\s*(\d+) failures?,\s*(\d+) errors?,\s*(\d+) skips?/);
+      if (minitestMatch) {
+        total = parseInt(minitestMatch[1], 10);
+        const failures = parseInt(minitestMatch[2], 10);
+        const errors = parseInt(minitestMatch[3], 10);
+        skipped = parseInt(minitestMatch[4], 10);
+        failed = failures + errors;
+        passed = total - failed - skipped;
+      }
+      break;
+    }
+    case "pest":
+    case "phpunit":
+    case "php-artisan": {
+      const phpunitMatch = output.match(/Tests:\s*(\d+),\s*Assertions:\s*\d+(?:,\s*Failures:\s*(\d+))?(?:,\s*Errors:\s*(\d+))?(?:,\s*Skipped:\s*(\d+))?/);
+      const okMatch = output.match(/OK\s*\((\d+)\s+tests?/);
+      if (phpunitMatch) {
+        total = parseInt(phpunitMatch[1], 10);
+        const failures = phpunitMatch[2] ? parseInt(phpunitMatch[2], 10) : 0;
+        const errors = phpunitMatch[3] ? parseInt(phpunitMatch[3], 10) : 0;
+        skipped = phpunitMatch[4] ? parseInt(phpunitMatch[4], 10) : 0;
+        failed = failures + errors;
+        passed = total - failed - skipped;
+      } else if (okMatch) {
+        total = parseInt(okMatch[1], 10);
+        passed = total;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  if (total === undefined)
+    total = passed + failed + skipped;
+  return {
+    ok: exitCode === 0,
+    raw: { stdout, stderr, exitCode },
+    passed,
+    failed,
+    skipped,
+    total,
+    ...coveragePercent !== undefined ? { coveragePercent } : {}
+  };
+}
+async function defaultDetectProject(profile, dir) {
+  for (const f of profile.build.detectFiles) {
+    if (detectFileExists(dir, f))
+      return true;
+  }
+  return false;
+}
+async function defaultSelectBuildCommand(profile, dir) {
+  const sorted = [...profile.build.commands].sort((a, b) => b.priority - a.priority);
+  for (const cmd of sorted) {
+    if (cmd.detectFile && !detectFileExists(dir, cmd.detectFile))
+      continue;
+    const resolved = resolveLocalCommand(cmd.cmd, dir, isCommandAvailable);
+    if (!resolved)
+      continue;
+    return {
+      name: cmd.name,
+      cmd: resolved.argv,
+      cwd: dir,
+      detectedVia: cmd.detectFile ?? `${profile.id} default`
+    };
+  }
+  return null;
+}
+async function defaultTestFilesFor(profile, sourceFile, dir) {
+  const ext = path3.extname(sourceFile);
+  if (!profile.extensions.includes(ext))
+    return [];
+  const base = path3.basename(sourceFile, ext);
+  const rel = path3.relative(dir, sourceFile);
+  const relDir = path3.dirname(rel);
+  const stripSrc = relDir.replace(/^src(\/|\\)/, "");
+  const candidates = new Set;
+  for (const tDir of ["tests", "test", "__tests__", "spec"]) {
+    for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
+      candidates.add(path3.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+    }
+  }
+  const existing = [];
+  for (const c of candidates) {
+    try {
+      fs3.accessSync(c);
+      existing.push(c);
+    } catch {}
+  }
+  return existing;
+}
+function defaultExtractImports() {
+  return [];
+}
+async function defaultSelectFramework() {
+  return null;
+}
+async function defaultSelectEntryPoints() {
+  return [];
+}
+function defaultBackendFor(profile) {
+  return {
+    ...profile,
+    detectProject: (dir) => defaultDetectProject(profile, dir),
+    selectTestFramework: (dir) => defaultSelectTestFramework(profile, dir),
+    buildTestCommand: (framework, files, dir, opts) => defaultBuildTestCommand(profile, framework, files, dir, opts),
+    parseTestOutput: (framework, stdout, stderr, exitCode) => defaultParseTestOutput(framework, stdout, stderr, exitCode),
+    testFilesFor: (sourceFile, dir) => defaultTestFilesFor(profile, sourceFile, dir),
+    extractImports: () => defaultExtractImports(),
+    selectBuildCommand: (dir) => defaultSelectBuildCommand(profile, dir),
+    selectFramework: () => defaultSelectFramework(),
+    selectEntryPoints: () => defaultSelectEntryPoints()
+  };
+}
+
+// src/lang/backends/go.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var PROFILE_ID = "go";
+var IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
+var IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
+var IMPORT_REGEX_GROUP_LINE = /(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/g;
+var MAX_IMPORT_SOURCE_BYTES = 1 * 1024 * 1024;
+function stripGoComments(source) {
+  let state = "normal";
+  let out = "";
+  let escaped = false;
+  for (let index = 0;index < source.length; index++) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (state === "line") {
+      if (current === `
+` || current === "\r") {
+        state = "normal";
+        out += current;
+      } else {
+        out += " ";
+      }
+      continue;
+    }
+    if (state === "block") {
+      if (current === "*" && next === "/") {
+        out += "  ";
+        index++;
+        state = "normal";
+      } else {
+        out += current === `
+` || current === "\r" ? current : " ";
+      }
+      continue;
+    }
+    if (state === "string") {
+      out += current;
+      if (escaped)
+        escaped = false;
+      else if (current === "\\")
+        escaped = true;
+      else if (current === '"')
+        state = "normal";
+      continue;
+    }
+    if (state === "raw") {
+      out += current;
+      if (current === "`")
+        state = "normal";
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      out += "  ";
+      index++;
+      state = "line";
+    } else if (current === "/" && next === "*") {
+      out += "  ";
+      index++;
+      state = "block";
+    } else {
+      out += current;
+      if (current === '"')
+        state = "string";
+      else if (current === "`")
+        state = "raw";
+    }
+  }
+  return out;
+}
+function extractImports(_sourceFile, source) {
+  if (Buffer.byteLength(source, "utf8") > MAX_IMPORT_SOURCE_BYTES)
+    return [];
+  const out = new Set;
+  const uncommented = stripGoComments(source);
+  IMPORT_REGEX_SINGLE.lastIndex = 0;
+  let m = IMPORT_REGEX_SINGLE.exec(uncommented);
+  while (m !== null) {
+    out.add(m[1]);
+    m = IMPORT_REGEX_SINGLE.exec(uncommented);
+  }
+  IMPORT_REGEX_GROUP.lastIndex = 0;
+  m = IMPORT_REGEX_GROUP.exec(uncommented);
+  while (m !== null) {
+    const block = m[1];
+    IMPORT_REGEX_GROUP_LINE.lastIndex = 0;
+    let inner = IMPORT_REGEX_GROUP_LINE.exec(block);
+    while (inner !== null) {
+      out.add(inner[1]);
+      inner = IMPORT_REGEX_GROUP_LINE.exec(block);
+    }
+    m = IMPORT_REGEX_GROUP.exec(uncommented);
+  }
+  return [...out];
+}
+async function selectFramework(dir) {
+  let content;
+  try {
+    content = fs4.readFileSync(path4.join(dir, "go.mod"), "utf-8");
+  } catch {
+    return null;
+  }
+  const candidates = [
+    ["github.com/gin-gonic/gin", "gin"],
+    ["github.com/labstack/echo", "echo"],
+    ["github.com/gofiber/fiber", "fiber"],
+    ["github.com/gorilla/mux", "gorilla"],
+    ["github.com/go-chi/chi", "chi"]
+  ];
+  for (const [pkg, name] of candidates) {
+    if (content.includes(pkg)) {
+      return { name, detectedVia: `go.mod require ${pkg}` };
+    }
+  }
+  return null;
+}
+async function selectEntryPoints(dir) {
+  const points = [];
+  try {
+    fs4.accessSync(path4.join(dir, "main.go"));
+    points.push("main.go");
+  } catch {}
+  try {
+    const cmdDir = path4.join(dir, "cmd");
+    const subdirs = fs4.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const sub of subdirs) {
+      const main = path4.join("cmd", sub.name, "main.go");
+      try {
+        fs4.accessSync(path4.join(dir, main));
+        points.push(main);
+      } catch {}
+    }
+  } catch {}
+  return points;
+}
+function buildGoBackend() {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID);
+  if (!profile) {
+    throw new Error("buildGoBackend: go profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
+  }
+  return {
+    ...defaultBackendFor(profile),
+    extractImports,
+    selectFramework,
+    selectEntryPoints
+  };
+}
+var _internals2 = { extractImports };
+
+// src/lang/backends/python.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var PROFILE_ID2 = "python";
+var IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
+var IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
+function parseImportTargets(rawTargets) {
+  const cleaned = rawTargets.replace(/[()]/g, "").split(`
+`).map((line) => line.replace(/#.*$/, "").replace(/\\\s*$/, "")).join(" ");
+  const out = [];
+  for (const seg of cleaned.split(",")) {
+    const trimmed = seg.trim();
+    if (trimmed.length === 0)
+      continue;
+    const name = trimmed.split(/\s+as\s+/)[0].trim();
+    if (/^[\w]+$/.test(name))
+      out.push(name);
+  }
+  return out;
+}
+function extractImports2(_sourceFile, source) {
+  const out = new Set;
+  source = source.replace(/\\\r?\n[ \t]*/g, " ");
+  IMPORT_REGEX_FROM_WITH_TARGETS.lastIndex = 0;
+  let m = IMPORT_REGEX_FROM_WITH_TARGETS.exec(source);
+  while (m !== null) {
+    const fromClause = m[1];
+    const targets = parseImportTargets(m[2]);
+    const isPurelyRelative = fromClause.length > 0 && /^\.+$/.test(fromClause);
+    if (isPurelyRelative && targets.length > 0) {
+      for (const t of targets)
+        out.add(`${fromClause}${t}`);
+    } else if (fromClause.length > 0) {
+      out.add(fromClause);
+    }
+    m = IMPORT_REGEX_FROM_WITH_TARGETS.exec(source);
+  }
+  IMPORT_REGEX_IMPORT.lastIndex = 0;
+  m = IMPORT_REGEX_IMPORT.exec(source);
+  while (m !== null) {
+    const segments = m[1].split(",");
+    for (const seg of segments) {
+      const trimmed = seg.trim();
+      if (trimmed.length === 0)
+        continue;
+      const mod = trimmed.split(/\s+as\s+/)[0].trim();
+      if (/^[\w.]+$/.test(mod))
+        out.add(mod);
+    }
+    m = IMPORT_REGEX_IMPORT.exec(source);
+  }
+  return [...out];
+}
+async function selectFramework2(dir) {
+  const candidates = [
+    ["django", "django"],
+    ["flask", "flask"],
+    ["fastapi", "fastapi"],
+    ["starlette", "starlette"],
+    ["tornado", "tornado"],
+    ["aiohttp", "aiohttp"],
+    ["bottle", "bottle"]
+  ];
+  for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
+    try {
+      const content = fs5.readFileSync(path5.join(dir, candidate), "utf-8");
+      const lower = content.toLowerCase();
+      for (const [pkg, name] of candidates) {
+        if (lower.includes(pkg)) {
+          return { name, detectedVia: candidate };
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+async function selectEntryPoints2(dir) {
+  const points = new Set;
+  try {
+    const content = fs5.readFileSync(path5.join(dir, "pyproject.toml"), "utf-8");
+    const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
+    if (scriptsBlock) {
+      for (const line of scriptsBlock[0].split(`
+`)) {
+        const m = line.match(/=\s*['"]([^'":]+)/);
+        if (m) {
+          const modPath = `${m[1].replace(/\./g, "/")}.py`;
+          points.add(modPath);
+        }
+      }
+    }
+  } catch {}
+  for (const name of ["manage.py", "main.py", "app.py", "__main__.py"]) {
+    try {
+      fs5.accessSync(path5.join(dir, name));
+      points.add(name);
+    } catch {}
+  }
+  return [...points];
+}
+function buildPythonBackend() {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID2);
+  if (!profile) {
+    throw new Error("buildPythonBackend: python profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
+  }
+  return {
+    ...defaultBackendFor(profile),
+    extractImports: extractImports2,
+    selectFramework: selectFramework2,
+    selectEntryPoints: selectEntryPoints2
+  };
+}
+var _internals3 = { extractImports: extractImports2 };
+
+export { LANGUAGE_REGISTRY, getProfileForFile, detectProjectLanguages, tokenizeCommand, resolveLocalNodeTool, isCommandAvailable, defaultSelectTestFramework, defaultBuildTestCommand, buildNativeTargetCommand, defaultParseTestOutput, defaultSelectBuildCommand, defaultTestFilesFor, defaultBackendFor, buildGoBackend, _internals2 as _internals, buildPythonBackend, _internals3 as _internals1 };