@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-6T6NHXK4.js

@@ -0,0 +1,230 @@
+import {
+  getBuiltInTaskTypesDir,
+  getRepoTaskTypesDir
+} from "./chunk-STW7OFOA.js";
+import {
+  deepMerge
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/task-types/types.ts
+import { z } from "zod";
+var TaskTypeStageTypeSchema = z.enum([
+  "standard",
+  "competition",
+  "verify",
+  "autoloop",
+  "refinement"
+]);
+var TaskTypeExecutionIntentSchema = z.enum(["edit", "analysis"]);
+var TaskTypeStrategySchema = z.string().trim().min(1);
+var TaskTypeJudgingFrameworkSchema = z.preprocess(
+  (value) => value === "hybrid" ? "auto" : value,
+  z.enum(["multi-lens", "ai-judge", "auto"])
+);
+var TaskTypeAllowlistModeSchema = z.enum(["strict", "warn", "off"]);
+var TaskTypePolicySchema = z.object({
+  executionIntent: TaskTypeExecutionIntentSchema.optional(),
+  routing: z.object({
+    defaultStrategy: TaskTypeStrategySchema.optional(),
+    preferCompetition: z.boolean().optional()
+  }).passthrough().optional(),
+  decomposition: z.object({
+    requiredStageTypes: z.array(TaskTypeStageTypeSchema).optional(),
+    maxParallelGroups: z.number().int().positive().optional(),
+    guidance: z.object({
+      hints: z.array(z.string()).optional(),
+      antiPatterns: z.array(z.string()).optional()
+    }).passthrough().optional()
+  }).passthrough().optional(),
+  judging: z.object({
+    framework: TaskTypeJudgingFrameworkSchema.optional(),
+    defaultScore: z.number().min(0).max(100).optional(),
+    minimumScore: z.number().min(0).max(100).optional()
+  }).passthrough().optional(),
+  allowlist: z.object({
+    requireNonEmpty: z.boolean().optional(),
+    mode: TaskTypeAllowlistModeSchema.optional()
+  }).passthrough().optional(),
+  verify: z.object({
+    defaultCommands: z.array(z.string()).optional()
+  }).passthrough().optional()
+}).passthrough();
+var TaskTypeMatchSchema = z.object({
+  priority: z.number().int().optional(),
+  canonical: z.object({
+    category: z.array(z.string()).optional(),
+    judgeTaskKind: z.array(z.string()).optional()
+  }).optional(),
+  keywords: z.array(z.string()).optional(),
+  regex: z.array(z.string()).optional(),
+  // When true, this task type is suppressed for prompts that carry strong
+  // code-only signals unless the prompt also has a direct documentation
+  // deliverable intent. Data-driven replacement for a hardcoded id check in
+  // the resolver; set on the doc task type definition(s).
+  suppressWhenCodeOnly: z.boolean().optional()
+}).passthrough().optional();
+var TaskTypeDefinitionSchema = z.object({
+  id: z.string().min(1),
+  version: z.number().int().positive().default(1),
+  extends: z.string().min(1).optional(),
+  match: TaskTypeMatchSchema,
+  policy: TaskTypePolicySchema.optional()
+}).passthrough();
+
+// src/core/task-types/registry.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+// src/core/task-types/merge.ts
+function mergePolicy(parent, child) {
+  if (!child) return parent;
+  return deepMerge(parent, child);
+}
+function getPolicy(def) {
+  return def.policy ?? {};
+}
+
+// src/core/task-types/registry.ts
+var TaskTypeRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TaskTypeRegistryError";
+  }
+};
+async function listYamlFiles(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml"))).map((e) => path.join(dir, e.name)).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+async function loadDefinitionsFromDir(dir, source) {
+  const files = await listYamlFiles(dir);
+  const loaded = [];
+  for (const filePath of files) {
+    const raw = await fs.readFile(filePath, "utf8");
+    let parsed;
+    try {
+      parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new TaskTypeRegistryError(`Failed to parse task type YAML: ${filePath}. ${message}`);
+    }
+    const result = TaskTypeDefinitionSchema.safeParse(parsed);
+    if (!result.success) {
+      const issues = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+      throw new TaskTypeRegistryError(`Invalid task type YAML: ${filePath}. ${issues}`);
+    }
+    loaded.push({ definition: result.data, sourcePath: filePath, source });
+  }
+  return loaded;
+}
+function detectCycles(id, graph, visiting, visited, pathStack) {
+  if (visited.has(id)) return;
+  if (visiting.has(id)) {
+    const start = pathStack.indexOf(id);
+    const cycle = [...pathStack.slice(start), id].join(" -> ");
+    throw new TaskTypeRegistryError(`Circular task type extends detected: ${cycle}`);
+  }
+  visiting.add(id);
+  pathStack.push(id);
+  const parent = graph.get(id);
+  if (parent) {
+    detectCycles(parent, graph, visiting, visited, [...pathStack]);
+  }
+  visiting.delete(id);
+  visited.add(id);
+}
+function resolvePolicy(id, defs, resolved) {
+  const existing = resolved.get(id);
+  if (existing) return existing;
+  const versions = defs.get(id);
+  if (!versions || versions.length === 0) {
+    throw new TaskTypeRegistryError(`Task type not found: ${id}`);
+  }
+  const effective = versions.at(-1);
+  if (!effective) {
+    throw new TaskTypeRegistryError(`Task type not found: ${id}`);
+  }
+  const def = effective.definition;
+  const parentId = def.extends;
+  let basePolicy = {};
+  if (parentId) {
+    if (!defs.has(parentId)) {
+      throw new TaskTypeRegistryError(`Task type "${id}" extends unknown parent "${parentId}"`);
+    }
+    const parentResolved = resolvePolicy(parentId, defs, resolved);
+    basePolicy = parentResolved.policy;
+  }
+  const policy = mergePolicy(basePolicy, getPolicy(def));
+  const sources = versions.map((v) => ({ path: v.sourcePath, source: v.source }));
+  const finalResolved = {
+    id: def.id,
+    version: def.version,
+    extends: def.extends,
+    match: def.match,
+    policy,
+    sources
+  };
+  resolved.set(id, finalResolved);
+  return finalResolved;
+}
+var TaskTypeRegistry = class _TaskTypeRegistry {
+  defsById;
+  resolvedById;
+  constructor(defsById, resolvedById) {
+    this.defsById = defsById;
+    this.resolvedById = resolvedById;
+  }
+  static async load(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const builtInDir = options.builtInDir ?? getBuiltInTaskTypesDir();
+    const repoDir = options.repoDir ?? getRepoTaskTypesDir(cwd);
+    const loaded = [];
+    loaded.push(...await loadDefinitionsFromDir(builtInDir, "built-in"));
+    loaded.push(...await loadDefinitionsFromDir(repoDir, "repo"));
+    const defsById = /* @__PURE__ */ new Map();
+    for (const entry of loaded) {
+      const id = entry.definition.id;
+      const bucket = defsById.get(id) ?? [];
+      bucket.push(entry);
+      defsById.set(id, bucket);
+    }
+    const graph = /* @__PURE__ */ new Map();
+    for (const [id, versions] of defsById.entries()) {
+      const effective = versions.at(-1);
+      if (!effective) {
+        continue;
+      }
+      graph.set(id, effective.definition.extends);
+    }
+    const visiting = /* @__PURE__ */ new Set();
+    const visited = /* @__PURE__ */ new Set();
+    for (const id of defsById.keys()) {
+      detectCycles(id, graph, visiting, visited, []);
+    }
+    const resolvedById = /* @__PURE__ */ new Map();
+    for (const id of defsById.keys()) {
+      resolvePolicy(id, defsById, resolvedById);
+    }
+    return new _TaskTypeRegistry(defsById, resolvedById);
+  }
+  listIds() {
+    return [...this.resolvedById.keys()].sort((a, b) => a.localeCompare(b));
+  }
+  get(id) {
+    return this.resolvedById.get(id) ?? null;
+  }
+  getSources(id) {
+    return this.defsById.get(id) ?? [];
+  }
+};
+
+export {
+  TaskTypePolicySchema,
+  listYamlFiles,
+  TaskTypeRegistry
+};
+//# sourceMappingURL=chunk-6T6NHXK4.js.map

package/dist/chunk-6TBEX4R4.js

@@ -0,0 +1,432 @@
+import {
+  parseVerificationErrorsForCommand
+} from "./chunk-PXKERBKX.js";
+import {
+  detectEmptyRun,
+  detectEmptyRunOfResult,
+  detectResolverSuiteRunner,
+  parseGenericPassFailOutput,
+  parseTestOutput
+} from "./chunk-TUQMMFEQ.js";
+import {
+  describeVerificationCommand,
+  detectExitZeroVerifyFailure,
+  detectVerificationToolUnavailable
+} from "./chunk-EPAMVGI3.js";
+
+// src/core/project/audit-vulnerability-counts.ts
+var PIP_AUDIT_TABLE_HEADER = /^Name\s+Version\s+ID\s+Fix Versions\b/;
+var PIP_AUDIT_FOUND = /^Found (\d+) known vulnerabilit(?:y|ies) in \d+ packages?/m;
+function countPipAuditVulnerabilities(output) {
+  const lines = output.split("\n").map((line) => line.trimEnd());
+  const header = lines.findIndex((line) => PIP_AUDIT_TABLE_HEADER.test(line));
+  if (header === -1) {
+    return /^No known vulnerabilities found/m.test(output) ? 0 : null;
+  }
+  if (!/^-+(?:\s+-+)+$/.test(lines[header + 1]?.trim() ?? "")) {
+    return null;
+  }
+  let rows = 0;
+  const advisories = /* @__PURE__ */ new Set();
+  for (const line of lines.slice(header + 2)) {
+    if (line.trim() === "") break;
+    const columns = line.trim().split(/\s+/);
+    if (columns.length < 3) return null;
+    rows += 1;
+    advisories.add(`${columns[0]} ${columns[2]}`);
+  }
+  const reported = PIP_AUDIT_FOUND.exec(output);
+  if (rows === 0 || !reported || Number(reported[1]) !== rows) {
+    return null;
+  }
+  return advisories.size;
+}
+function countGovulncheckVulnerabilities(output) {
+  const affected = /Your code is affected by (\d+) vulnerabilit(?:y|ies)/.exec(output);
+  if (affected) return Number(affected[1]);
+  return /^No vulnerabilities found\.$/m.test(output) ? 0 : null;
+}
+function countCargoAuditVulnerabilities(output) {
+  const found = /^error: (\d+) vulnerabilit(?:y|ies) found!/m.exec(output);
+  return found ? Number(found[1]) : null;
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function countYarnNpmAuditAdvisories(output) {
+  const lines = output.split("\n").filter((line) => line.trim() !== "");
+  if (lines.length === 0) return null;
+  const advisories = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const entry = parseJson(line);
+    const id = entry?.children?.ID;
+    if (typeof entry?.value !== "string" || typeof id !== "number" && typeof id !== "string") {
+      return null;
+    }
+    advisories.add(`${entry.value} ${id}`);
+  }
+  return advisories.size;
+}
+function countYarnClassicAuditAdvisories(output) {
+  const advisories = /* @__PURE__ */ new Set();
+  let finished = false;
+  for (const line of output.split("\n")) {
+    if (line.trim() === "") continue;
+    const entry = parseJson(line);
+    if (entry?.type === "auditSummary") {
+      finished = true;
+      continue;
+    }
+    if (entry?.type === "info" || entry?.type === "warning") continue;
+    const { id, module_name: name } = entry?.data?.advisory ?? {};
+    if (entry?.type !== "auditAdvisory" || typeof name !== "string") return null;
+    if (typeof id !== "number" && typeof id !== "string") return null;
+    advisories.add(`${name} ${id}`);
+  }
+  return finished ? advisories.size : null;
+}
+function countBunAuditAdvisories(output) {
+  const report = parseJson(output.trim());
+  if (typeof report !== "object" || report === null || Array.isArray(report)) return null;
+  const advisories = /* @__PURE__ */ new Set();
+  for (const [name, entries] of Object.entries(report)) {
+    if (!Array.isArray(entries)) return null;
+    for (const entry of entries) {
+      if (typeof entry?.id !== "number" && typeof entry?.id !== "string") return null;
+      advisories.add(`${name} ${entry.id}`);
+    }
+  }
+  return advisories.size;
+}
+var YARN_CLASSIC_AUDIT = /^yarn\s+audit(?:\s|$)/;
+var AUDIT_COUNT_TABLE = [
+  { command: /^pip-audit(?:\s|$)/, count: countPipAuditVulnerabilities },
+  { command: /^govulncheck(?:\s|$)/, count: countGovulncheckVulnerabilities },
+  { command: /^cargo(?:\s+\+\S+)?\s+audit(?:\s|$)/, count: countCargoAuditVulnerabilities },
+  { command: /^yarn\s+npm\s+audit(?:\s|$)/, count: countYarnNpmAuditAdvisories, json: true },
+  { command: YARN_CLASSIC_AUDIT, count: countYarnClassicAuditAdvisories, json: true },
+  { command: /^bun\s+audit(?:\s|$)/, count: countBunAuditAdvisories, json: true }
+];
+function auditCommandHead(command) {
+  const withoutEnv = command.trim().replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)+/, "");
+  const [first = "", ...rest] = withoutEnv.split(/\s+/);
+  const tool = first.replace(/^.*[\\/]/, "").replace(/\.exe$/i, "");
+  return [tool, ...rest].join(" ");
+}
+function countAuditVulnerabilitiesByTool(command, stdout, stderr) {
+  if (!command) return void 0;
+  const head = auditCommandHead(command);
+  const row = AUDIT_COUNT_TABLE.find((entry) => entry.command.test(head));
+  if (!row) return void 0;
+  return row.count(row.json ? stdout : `${stdout}
+
+${stderr}`);
+}
+function countSecurityVulnerabilities(result, fallback) {
+  const counted = countAuditVulnerabilitiesByTool(result.command, result.stdout, result.stderr);
+  return counted === void 0 ? fallback(result.stdout) : counted;
+}
+function yarnClassicAuditBlocks(command, exitCode, stdout) {
+  if (!YARN_CLASSIC_AUDIT.test(auditCommandHead(command))) return void 0;
+  if (countYarnClassicAuditAdvisories(stdout) === null) return void 0;
+  return (exitCode & 24) !== 0;
+}
+
+// src/core/project/resolver-gate-classify.ts
+var NODE_TEST_RUNNERS = ["vitest", "jest", "mocha", "ava", "node-test"];
+function readReportedTestCounts(command, output) {
+  const generic = parseGenericPassFailOutput(output, command);
+  if (generic.metricsMeasured) return generic;
+  const suiteRunner = detectResolverSuiteRunner([command]);
+  const runners = suiteRunner ? [suiteRunner] : describeVerificationCommand(command).language === "node" ? NODE_TEST_RUNNERS : [];
+  for (const runner of runners) {
+    const metrics = parseTestOutput(runner, output, command);
+    if (metrics.metricsMeasured) return metrics;
+  }
+  return void 0;
+}
+function runnerOutput(result) {
+  return result.all ?? `${String(result.stdout ?? "")}
+${String(result.stderr ?? "")}`;
+}
+function verifierOutput(result) {
+  return [
+    runnerOutput(result),
+    "shortMessage" in result ? result.shortMessage : void 0,
+    "message" in result ? result.message : void 0
+  ].filter((value) => value !== void 0 && value !== null).map(String).join("\n");
+}
+function classifyResolverCommand(command, result, durationMs, hint) {
+  const core = classifyResolverCommandCore(command, result, durationMs, hint);
+  const parsed = core.classification === "failed" ? parseVerificationErrorsForCommand(command, verifierOutput(result), true).parsed : false;
+  const exitCode = core.classification === "failed" && typeof result.exitCode === "number" ? result.exitCode : void 0;
+  return { ...core, ...exitCode !== void 0 ? { exitCode } : {}, parsed };
+}
+function emptyRunOutcome(command, reason, stdout, stderr, durationMs) {
+  return {
+    classification: "unavailable",
+    unavailableReason: "zero_tests",
+    zeroTestsNoEvidence: true,
+    command,
+    message: `Verification command "${command}" produced no test evidence (${reason}).`,
+    stdout,
+    stderr,
+    durationMs
+  };
+}
+function classifyResolverCommandCore(command, result, durationMs, hint) {
+  const rawExitCode = result.exitCode;
+  const all = verifierOutput(result);
+  const stdout = String(result.stdout ?? "");
+  const stderr = String(result.stderr ?? "");
+  const timedOut = result.timedOut === true;
+  const failed = result.failed === true;
+  if (timedOut) {
+    return {
+      classification: "timeout",
+      command,
+      message: `Verification command "${command}" timed out before completing.`,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  if (rawExitCode === void 0 || rawExitCode === null) {
+    const toolUnavailable2 = detectVerificationToolUnavailable(command, all);
+    const typedUnavailable = "toolUnavailable" in result && result.toolUnavailable === true;
+    if (typedUnavailable || toolUnavailable2 !== void 0) {
+      return {
+        classification: "unavailable",
+        // A typed refusal is decided before launch by the worktree environment.
+        unavailableReason: typedUnavailable ? "setup" : toolUnavailable2?.unavailableReason ?? "launcher_missing",
+        command,
+        message: typedUnavailable ? `Verification command "${command}" unavailable: ${all.trim()}` : `Verification command "${command}" unavailable: ${toolUnavailable2?.message ?? ""}`,
+        stdout,
+        stderr,
+        durationMs
+      };
+    }
+    return {
+      classification: "failed",
+      command,
+      message: `Verification command "${command}" did not exit cleanly (no exit code).`,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  const exitCode = rawExitCode;
+  const lockfileRequired = detectCargoLockedLockfileRequired(command, all);
+  if (lockfileRequired) {
+    return {
+      classification: "unavailable",
+      unavailableReason: "lockfile_required",
+      command,
+      message: lockfileRequired,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  if (exitCode === 0) {
+    const exitZeroFailure = detectExitZeroVerifyFailure(command, all);
+    if (exitZeroFailure) {
+      return {
+        classification: "failed",
+        command,
+        message: `Verification command failed despite exit 0: ${exitZeroFailure.message}`,
+        stdout,
+        stderr,
+        durationMs
+      };
+    }
+    const emptyRun2 = detectEmptyRun(command, all, 0, hint);
+    if (emptyRun2) {
+      return emptyRunOutcome(command, emptyRun2.reason, stdout, stderr, durationMs);
+    }
+    if (failed) {
+      return {
+        classification: "failed",
+        command,
+        message: `Verification command "${command}" reported failure despite exit 0.`,
+        stdout,
+        stderr,
+        durationMs
+      };
+    }
+    const unmeasured = describeVerificationCommand(command, hint).kind === "test" && !readReportedTestCounts(command, runnerOutput(result));
+    return {
+      classification: "passed",
+      command,
+      message: `Verification command "${command}" passed.`,
+      stdout,
+      stderr,
+      durationMs,
+      ...unmeasured ? { unmeasured: true } : {}
+    };
+  }
+  if (exitCode === 124) {
+    return {
+      classification: "timeout",
+      command,
+      message: `Verification command "${command}" timed out (exit 124).`,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  if (yarnClassicAuditBlocks(command, exitCode, stdout) === false) {
+    return {
+      classification: "passed",
+      command,
+      message: `Verification command "${command}" passed (exit ${exitCode}: no high or critical advisory).`,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  const toolUnavailable = detectVerificationToolUnavailable(command, all, exitCode);
+  if (toolUnavailable !== void 0) {
+    return {
+      classification: "unavailable",
+      unavailableReason: toolUnavailable.unavailableReason ?? "launcher_missing",
+      command,
+      message: `Verification command "${command}" unavailable: ${toolUnavailable.message}`,
+      stdout,
+      stderr,
+      durationMs
+    };
+  }
+  const emptyRun = detectEmptyRunOfResult(command, result, all, hint);
+  if (emptyRun) {
+    return emptyRunOutcome(command, emptyRun.reason, stdout, stderr, durationMs);
+  }
+  return {
+    classification: "failed",
+    command,
+    message: `Verification command "${command}" failed (exit ${exitCode}).`,
+    stdout,
+    stderr,
+    durationMs
+  };
+}
+function detectResolverUnavailableBlocker(command, output, exitCode) {
+  return detectResolverUnavailableSignal(command, output, exitCode)?.message;
+}
+function detectResolverUnavailableSignal(command, output, exitCode) {
+  if (exitCode === 0) return void 0;
+  return detectUnavailableSignal(command, output, exitCode) ?? detectEmptyRunSignal(command, output, exitCode);
+}
+function detectUnavailableSignal(command, output, exitCode, processExitCode) {
+  const lockfileRequired = detectCargoLockedLockfileRequired(command, output);
+  if (lockfileRequired) {
+    return {
+      toolchain: describeVerificationCommand(command).language,
+      message: lockfileRequired,
+      unavailableReason: "lockfile_required"
+    };
+  }
+  return detectVerificationToolUnavailable(command, output, exitCode, processExitCode);
+}
+function detectEmptyRunSignal(command, output, exitCode) {
+  const emptyRun = detectEmptyRun(command, output, exitCode);
+  return emptyRun ? {
+    toolchain: describeVerificationCommand(command).language,
+    message: `Verification unavailable: ${emptyRun.message}`,
+    unavailableReason: "zero_tests"
+  } : void 0;
+}
+function zeroTestsUnavailableSignal(command) {
+  return {
+    toolchain: describeVerificationCommand(command).language,
+    message: `Verification unavailable: ${command} ran no tests; no verification evidence.`,
+    unavailableReason: "zero_tests"
+  };
+}
+function launcherMissingUnavailableSignal(command, output) {
+  return {
+    toolchain: describeVerificationCommand(command).language,
+    message: /Verification tool unavailable:[^\n]*/.exec(output ?? "")?.[0] ?? `Verification tool unavailable: '${command}' could not be launched.`,
+    unavailableReason: "launcher_missing"
+  };
+}
+function detectCargoLockedLockfileRequired(command, output) {
+  const normalizedCommand = command.trim().replace(/\s+/g, " ").toLowerCase();
+  if (!/^cargo\s+/.test(normalizedCommand) || !/(?:^|\s)--locked(?:\s|$)/.test(normalizedCommand)) {
+    return void 0;
+  }
+  if (!/\bcargo\.lock\b/i.test(output) || !/(?:^|[^\w-])--locked(?:$|[^\w-])/i.test(output) || // Newer Cargo (seen on 1.99) words a missing lockfile as "cannot create the
+  // lock file .../Cargo.lock because --locked was passed to prevent this".
+  !/\b(?:needs to be updated|missing|does not exist|unable to update|cannot create the lock file)\b/i.test(
+    output
+  )) {
+    return void 0;
+  }
+  return "Verification unavailable: Cargo.lock is required for cargo --locked verification but is missing or outdated. Generate and commit an up-to-date Cargo.lock (for example, run cargo generate-lockfile or run the cargo verification command once without --locked), then rerun verification.";
+}
+function aggregateResolverOutcomes(outcomes) {
+  const classification = dominantVerificationStatus(outcomes.map((o) => o.classification));
+  if (classification === void 0) {
+    return { classification: "unavailable", unavailableReason: "no_command" };
+  }
+  const first = outcomes.find((outcome) => outcome.classification === classification);
+  const representative = first && classification === "passed" && outcomes.length > 1 ? {
+    ...first,
+    message: `Verification commands passed: ${outcomes.map((o) => o.command).join("; ")}.`
+  } : first;
+  return classification === "unavailable" ? {
+    classification,
+    unavailableReason: representative?.unavailableReason ?? "launcher_missing",
+    representative
+  } : { classification, representative };
+}
+var VERIFICATION_STATUS_RANK = {
+  failed: 0,
+  error: 1,
+  timeout: 2,
+  unavailable: 3,
+  skipped: 4,
+  not_run: 5,
+  passed: 6
+};
+function dominantVerificationStatus(statuses) {
+  let dominant;
+  for (const status of statuses) {
+    const rank = VERIFICATION_STATUS_RANK[status] ?? 0;
+    if (dominant === void 0 || rank < (VERIFICATION_STATUS_RANK[dominant] ?? 0)) {
+      dominant = status;
+    }
+  }
+  return dominant;
+}
+function bucketCommandOutcomes(outcomes) {
+  return outcomes.map(
+    ({ command, classification, unavailableReason, exitCode, stdout, stderr }) => classification === "passed" ? { command, timedOut: false, passed: true, stdout: "", stderr: "" } : {
+      command,
+      timedOut: classification === "timeout",
+      ...classification === "unavailable" ? { unavailable: true, unavailableReason } : {},
+      ...exitCode !== void 0 ? { exitCode } : {},
+      stdout,
+      stderr
+    }
+  );
+}
+
+export {
+  countSecurityVulnerabilities,
+  classifyResolverCommand,
+  detectResolverUnavailableBlocker,
+  detectResolverUnavailableSignal,
+  detectUnavailableSignal,
+  detectEmptyRunSignal,
+  zeroTestsUnavailableSignal,
+  launcherMissingUnavailableSignal,
+  aggregateResolverOutcomes,
+  dominantVerificationStatus,
+  bucketCommandOutcomes
+};
+//# sourceMappingURL=chunk-6TBEX4R4.js.map