opencode-agent-skill 7.7.0 → 10.0.0

package/lib/trajectory.mjs

@@ -0,0 +1,89 @@
+import { createHash, randomUUID } from "node:crypto"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import path from "node:path"
+
+const TRACE_DIR = ".ues-traces"
+const MAX_EVENT_BYTES = 64 * 1024
+
+function cleanID(value) {
+  const text = String(value || "").trim()
+  if (/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,100}$/.test(text)) return text
+  return "trace-" + randomUUID()
+}
+
+function redactString(value) {
+  let text = String(value)
+  const patterns = [
+    [/(authorization\s*[:=]\s*bearer\s+)[^\s"'\\]+/gi, "$1[REDACTED]"],
+    [/\b(sk-[A-Za-z0-9_-]{12,})\b/g, "[REDACTED_OPENAI_KEY]"],
+    [/\b(gh[pousr]_[A-Za-z0-9]{20,})\b/g, "[REDACTED_GITHUB_TOKEN]"],
+    [/\b(npm_[A-Za-z0-9]{20,})\b/g, "[REDACTED_NPM_TOKEN]"],
+    [/((?:api[_-]?key|token|secret|password|passwd|credential)\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;}]+)/gi, "$1[REDACTED]"],
+  ]
+  for (const [pattern, replacement] of patterns) text = text.replace(pattern, replacement)
+  return text
+}
+
+export function scrubTrajectoryValue(value, depth = 0) {
+  if (depth > 12) return "[TRUNCATED_DEPTH]"
+  if (typeof value === "string") return redactString(value)
+  if (Array.isArray(value)) return value.slice(0, 200).map((item) => scrubTrajectoryValue(item, depth + 1))
+  if (!value || typeof value !== "object") return value
+  const result = {}
+  for (const [key, child] of Object.entries(value)) {
+    if (/^(authorization|cookie|set-cookie|api[_-]?key|token|secret|password|passwd|credential)$/i.test(key)) {
+      result[key] = "[REDACTED]"
+      continue
+    }
+    result[key] = scrubTrajectoryValue(child, depth + 1)
+  }
+  return result
+}
+
+export function createTraceID(prefix = "run") {
+  return cleanID(prefix + "-" + new Date().toISOString().replace(/[:.]/g, "-") + "-" + randomUUID().slice(0, 8))
+}
+
+export function trajectoryFile(root, traceID) {
+  return path.join(path.resolve(root), TRACE_DIR, cleanID(traceID) + ".jsonl")
+}
+
+export async function appendTrajectoryEvent(root, traceID, type, payload = {}) {
+  const file = trajectoryFile(root, traceID)
+  await mkdir(path.dirname(file), { recursive: true })
+  const scrubbed = scrubTrajectoryValue(payload)
+  const rawPayload = JSON.stringify(scrubbed)
+  const bounded = Buffer.byteLength(rawPayload, "utf8") <= MAX_EVENT_BYTES
+    ? scrubbed
+    : {
+        truncated: true,
+        sha256: createHash("sha256").update(rawPayload).digest("hex"),
+        preview: redactString(rawPayload.slice(0, MAX_EVENT_BYTES - 1024)),
+      }
+  const event = {
+    schemaVersion: 1,
+    id: randomUUID(),
+    traceID: cleanID(traceID),
+    type: String(type || "event"),
+    at: new Date().toISOString(),
+    payload: bounded,
+  }
+  await writeFile(file, JSON.stringify(event) + "\n", { encoding: "utf8", flag: "a" })
+  return { file: path.relative(path.resolve(root), file).replaceAll("\\", "/"), event }
+}
+
+export async function readTrajectory(root, traceID, options = {}) {
+  const file = trajectoryFile(root, traceID)
+  const source = await readFile(file, "utf8").catch(() => "")
+  const limit = Math.max(1, Math.min(Number(options.limit || 200), 2000))
+  const events = source.split(/\r?\n/).filter(Boolean).map((line) => {
+    try { return JSON.parse(line) } catch { return null }
+  }).filter(Boolean)
+  return {
+    traceID: cleanID(traceID),
+    file: path.relative(path.resolve(root), file).replaceAll("\\", "/"),
+    events: events.slice(-limit),
+    total: events.length,
+    note: "Operational prompts/actions/observations only; hidden chain-of-thought is never recorded.",
+  }
+}

package/lib/windows-shim.mjs

@@ -0,0 +1,227 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+
+function within(base, candidate) {
+  const root = path.resolve(base)
+  const full = path.resolve(candidate)
+  return full === root || full.startsWith(root + path.sep)
+}
+
+function looksLikeNodeScript(file) {
+  try {
+    const head = readFileSync(file, "utf8").slice(0, 512)
+    const firstLine = head.split(/\r?\n/, 1)[0]
+    return /^#!.*(?:\/|\\|\b)node(?:\.exe)?(?:\s|$)/i.test(firstLine)
+  } catch {
+    return false
+  }
+}
+
+
+function looksLikeWindowsExecutable(file) {
+  try {
+    const head = readFileSync(file)
+    return head.length >= 2 && head[0] === 0x4d && head[1] === 0x5a
+  } catch {
+    return false
+  }
+}
+
+function executionForTarget(target) {
+  const ext = path.extname(target).toLowerCase()
+  if ([".exe", ".com"].includes(ext) && looksLikeWindowsExecutable(target)) {
+    return {
+      executable: target,
+      argsPrefix: [],
+      kind: "native",
+      entry: target,
+    }
+  }
+  if ([".js", ".mjs", ".cjs"].includes(ext) || (!ext && looksLikeNodeScript(target))) {
+    return {
+      executable: process.execPath,
+      argsPrefix: [target],
+      kind: "node-shim",
+      entry: target,
+    }
+  }
+  return null
+}
+
+
+function packageBinTarget(packageDir, commandName) {
+  let pkg
+  try {
+    pkg = JSON.parse(readFileSync(path.join(packageDir, "package.json"), "utf8"))
+  } catch {
+    return null
+  }
+
+  const bin = pkg?.bin
+  let relative = null
+  if (typeof bin === "string") {
+    const packageCommand = String(pkg?.name || "").split("/").at(-1)
+    if (packageCommand === commandName) relative = bin
+  } else if (bin && typeof bin === "object" && typeof bin[commandName] === "string") {
+    relative = bin[commandName]
+  }
+  if (!relative) return null
+
+  const target = path.resolve(packageDir, relative)
+  if (!within(packageDir, target) || !existsSync(target)) return null
+  return executionForTarget(target) ? target : null
+}
+
+function adjacentPackageBin(cmdPath) {
+  const fullCmd = path.resolve(String(cmdPath || ""))
+  const commandName = path.basename(fullCmd).replace(/\.(?:cmd|bat)$/i, "")
+  const nodeModulesRoot = path.join(path.dirname(fullCmd), "node_modules")
+  let entries = []
+  try {
+    entries = readdirSync(nodeModulesRoot, { withFileTypes: true })
+  } catch {
+    return null
+  }
+
+  let inspected = 0
+  for (const entry of entries) {
+    if (inspected >= 2000) break
+    if (!entry.isDirectory()) continue
+
+    if (entry.name.startsWith("@")) {
+      let scoped = []
+      try {
+        scoped = readdirSync(path.join(nodeModulesRoot, entry.name), { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const child of scoped) {
+        if (inspected >= 2000) break
+        if (!child.isDirectory()) continue
+        inspected += 1
+        const target = packageBinTarget(
+          path.join(nodeModulesRoot, entry.name, child.name),
+          commandName,
+        )
+        if (target) return target
+      }
+      continue
+    }
+
+    inspected += 1
+    const target = packageBinTarget(path.join(nodeModulesRoot, entry.name), commandName)
+    if (target) return target
+  }
+  return null
+}
+
+function resolveShimTarget(cmdPath) {
+  const fullCmd = path.resolve(String(cmdPath || ""))
+  const dir = path.dirname(fullCmd)
+
+  if (/^npm(?:\.cmd|\.exe)?$/i.test(path.basename(fullCmd))) {
+    const npmEntry = path.join(dir, "node_modules", "npm", "bin", "npm-cli.js")
+    if (existsSync(npmEntry)) return npmEntry
+  }
+
+  let shim = ""
+  try {
+    shim = readFileSync(fullCmd, "utf8")
+  } catch {
+    return null
+  }
+
+  const nodeModulesRoot = path.join(dir, "node_modules")
+  const pattern = /node_modules[\\/](?:@[A-Za-z0-9._-]+[\\/])?[A-Za-z0-9._-]+(?:[\\/][A-Za-z0-9._+-]+)*/gi
+  const matches = [...shim.matchAll(pattern)].map((match) => match[0]).reverse()
+
+  for (const match of matches) {
+    const portableMatch = match.split(/[\\/]+/).join(path.sep)
+    const candidate = path.resolve(dir, portableMatch)
+    if (!within(nodeModulesRoot, candidate) || !existsSync(candidate)) continue
+    if (executionForTarget(candidate)) return candidate
+  }
+
+  // Some npm shims vary in formatting. Fall back to the adjacent global
+  // node_modules metadata and only trust an explicit package.json bin mapping
+  // for the command represented by this shim.
+  return adjacentPackageBin(fullCmd)
+}
+
+export function resolveNodeShimEntry(cmdPath) {
+  const target = resolveShimTarget(cmdPath)
+  if (!target) return null
+  const execution = executionForTarget(target)
+  return execution?.kind === "node-shim" ? target : null
+}
+
+function resolveShimExecution(cmdPath) {
+  const target = resolveShimTarget(cmdPath)
+  if (!target) return null
+  return executionForTarget(target)
+}
+
+export function resolveWindowsCommandCandidates(candidates = []) {
+  const values = [...new Set(
+    candidates.map((item) => String(item || "").trim()).filter(Boolean),
+  )]
+
+  // Respect PATH ordering, but only return a target that can be launched without
+  // invoking cmd.exe. npm commonly emits both an extensionless POSIX shim and a
+  // .cmd shim; either may point at a native .exe or a Node launcher.
+  for (const candidate of values) {
+    if (!existsSync(candidate)) continue
+    const ext = path.extname(candidate).toLowerCase()
+
+    if ([".exe", ".com"].includes(ext)) {
+      const direct = executionForTarget(candidate)
+      if (direct) return { ...direct, source: candidate }
+      continue
+    }
+
+    if ([".cmd", ".bat"].includes(ext)) {
+      const resolved = resolveShimExecution(candidate)
+      if (resolved) return { ...resolved, source: candidate }
+      continue
+    }
+
+    if (!ext) {
+      if (looksLikeNodeScript(candidate)) {
+        return {
+          executable: process.execPath,
+          argsPrefix: [candidate],
+          kind: "node-script",
+          source: candidate,
+          entry: candidate,
+        }
+      }
+      // npm's extensionless shim is normally a POSIX shell wrapper even on
+      // Windows. Parse its package target instead of trying to execute the shell.
+      const resolved = resolveShimExecution(candidate)
+      if (resolved) return { ...resolved, source: candidate }
+    }
+  }
+  return null
+}
+
+export function resolveWindowsCommand(name) {
+  const value = String(name || "").trim()
+  if (!value) return null
+
+  if (path.isAbsolute(value)) {
+    return resolveWindowsCommandCandidates([value])
+  }
+
+  const result = spawnWhere(value)
+  if (result.status !== 0 || !result.stdout) return null
+  const candidates = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  return resolveWindowsCommandCandidates(candidates)
+}
+
+function spawnWhere(name) {
+  // Lazy import avoidance is unnecessary here; child_process is builtin and this
+  // module is Node-only. Kept as one helper so tests can cover candidate selection
+  // without invoking the host PATH.
+  return spawnSync("where", [name], { encoding: "utf8" })
+}

package/lib/worktree-sandbox.mjs

@@ -3,8 +3,24 @@ import { mkdir, rm } from "node:fs/promises"
 import { spawnSync } from "node:child_process"
 import path from "node:path"
 
-function git(root, args) {
-  return spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 })
+function git(root, args, options = {}) {
+  return spawnSync("git", args, {
+    cwd: root,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    input: options.input,
+  })
+}
+
+function statusFiles(root) {
+  const result = git(root, ["status", "--porcelain=v1", "--untracked-files=all"])
+  if (result.status !== 0) throw new Error((result.stderr || result.stdout || "git status failed").trim())
+  return result.stdout
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => line.slice(3).trim())
+    .map((value) => value.includes(" -> ") ? value.split(" -> ").at(-1) : value)
+    .map((value) => value.replaceAll("\\", "/"))
 }
 
 function safeName(value) {
@@ -13,6 +29,11 @@ function safeName(value) {
 
 export async function createTaskSandbox(root, slug, taskID, options = {}) {
   root = path.resolve(root)
+  const status = git(root, ["status", "--porcelain=v1", "--untracked-files=all"])
+  if (status.status !== 0) throw new Error((status.stderr || status.stdout || "git status failed").trim())
+  if (status.stdout.trim() && options.allowDirtyRoot !== true) {
+    throw new Error("sandbox creation requires a clean root working tree so the isolated executor cannot miss existing uncommitted changes")
+  }
   const base = options.baseDir
     ? path.resolve(options.baseDir)
     : path.join(path.dirname(root), "." + path.basename(root) + ".ues-sandboxes")
@@ -30,16 +51,77 @@ export async function createTaskSandbox(root, slug, taskID, options = {}) {
   return { schemaVersion: 1, root, dir, branch, slug, taskID, startPoint }
 }
 
+export async function integrateTaskSandbox(root, dir, options = {}) {
+  root = path.resolve(root)
+  dir = path.resolve(dir)
+  if (!existsSync(dir)) throw new Error("sandbox does not exist: " + dir)
+
+  const rootTop = git(root, ["rev-parse", "--show-toplevel"])
+  const sandboxTop = git(dir, ["rev-parse", "--show-toplevel"])
+  if (rootTop.status !== 0 || sandboxTop.status !== 0) throw new Error("root and sandbox must be Git worktrees")
+  if (path.resolve(sandboxTop.stdout.trim()) !== dir) throw new Error("sandbox path is not the worktree root")
+
+  // Resolve the merge base against the canonical root HEAD explicitly.
+  const rootHead = git(root, ["rev-parse", "HEAD"])
+  const sandboxHead = git(dir, ["rev-parse", "HEAD"])
+  if (rootHead.status !== 0 || sandboxHead.status !== 0) throw new Error("could not resolve worktree HEADs")
+  const base = git(dir, ["merge-base", rootHead.stdout.trim(), sandboxHead.stdout.trim()])
+  if (base.status !== 0) throw new Error((base.stderr || base.stdout || "git merge-base failed").trim())
+  const baseSha = base.stdout.trim()
+
+  // Intent-to-add exposes untracked files in a binary diff without committing them.
+  const addIntent = git(dir, ["add", "-N", "."])
+  if (addIntent.status !== 0) throw new Error((addIntent.stderr || addIntent.stdout || "git add -N failed").trim())
+
+  const changedRun = git(dir, ["diff", "--name-only", baseSha, "--"])
+  if (changedRun.status !== 0) throw new Error((changedRun.stderr || changedRun.stdout || "git diff --name-only failed").trim())
+  const changed = changedRun.stdout.split(/\r?\n/).filter(Boolean).map((value) => value.replaceAll("\\", "/"))
+  if (changed.length === 0) {
+    if (!options.keep) await removeTaskSandbox(root, dir, { force: true, deleteBranch: true })
+    return { integrated: true, changed: [], base: baseSha, empty: true }
+  }
+
+  const rootDirty = new Set(statusFiles(root))
+  const overlap = changed.filter((file) => rootDirty.has(file))
+  if (overlap.length) {
+    throw new Error("sandbox integration conflicts with existing root changes: " + overlap.join(", "))
+  }
+
+  const patch = git(dir, ["diff", "--binary", "--no-ext-diff", baseSha, "--"])
+  if (patch.status !== 0) throw new Error((patch.stderr || patch.stdout || "git diff failed").trim())
+  const applied = git(root, ["apply", "--whitespace=nowarn", "-"], { input: patch.stdout })
+  if (applied.status !== 0) {
+    throw new Error((applied.stderr || applied.stdout || "git apply failed").trim())
+  }
+
+  if (!options.keep) await removeTaskSandbox(root, dir, { force: true, deleteBranch: true })
+  return { integrated: true, changed, base: baseSha, empty: false }
+}
+
 export async function removeTaskSandbox(root, dir, options = {}) {
   root = path.resolve(root)
   dir = path.resolve(dir)
+  let branch = options.branch || null
+  if (!branch && options.deleteBranch && existsSync(dir)) {
+    const currentBranch = git(dir, ["branch", "--show-current"])
+    if (currentBranch.status === 0) branch = currentBranch.stdout.trim() || null
+  }
   const result = git(root, ["worktree", "remove", ...(options.force ? ["--force"] : []), dir])
   if (result.status !== 0 && existsSync(dir)) {
     if (options.force) await rm(dir, { recursive: true, force: true })
     else throw new Error((result.stderr || result.stdout || "git worktree remove failed").trim())
   }
   git(root, ["worktree", "prune"])
-  return { removed: !existsSync(dir), dir }
+  if (options.deleteBranch && branch) {
+    if (!branch.startsWith("ues/")) {
+      throw new Error("refusing to delete non-UES sandbox branch: " + branch)
+    }
+    const deleted = git(root, ["branch", "-D", branch])
+    if (deleted.status !== 0) {
+      throw new Error((deleted.stderr || deleted.stdout || "git branch delete failed").trim())
+    }
+  }
+  return { removed: !existsSync(dir), dir, branch: branch || null }
 }
 
 export function listTaskSandboxes(root) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "version": "7.7.0",
-  "description": "Adaptive crash-safe engineering runtime, durable orchestration, structured evidence, learning loop and control center for OpenCode",
+  "version": "10.0.0",
+  "description": "Evidence-first engineering runtime with adaptive context, selective routing, weak-model recovery, bounded ACI and benchmark-gated verification for OpenCode",
   "type": "module",
   "bin": {
     "ocskill": "bin/ocskill.mjs"
@@ -23,7 +23,7 @@
     "evals": "node scripts/eval-skills.mjs",
     "evals:live:validate": "node scripts/validate-live-suite.mjs",
     "test": "node --test test/*.test.mjs",
-    "ci": "npm run syntax && npm run validate && npm run evals && npm run evals:router && npm run evals:live:validate && npm run evals:long:validate && npm test && npm pack --dry-run && npm run smoke:pack",
+    "ci": "npm run syntax && npm run validate && npm run evals && npm run evals:router && npm run evals:live:validate && npm run evals:long:validate && npm run evals:polyglot:validate && npm test && npm pack --dry-run && npm run smoke:pack && npm run smoke:plain-install",
     "postinstall": "node scripts/install.mjs",
     "preuninstall": "node scripts/uninstall.mjs",
     "prepublishOnly": "npm run ci",
@@ -39,7 +39,14 @@
     "evals:router": "node scripts/eval-router.mjs",
     "evals:long:validate": "node scripts/validate-live-suite.mjs --suite long",
     "evals:long": "node scripts/eval-live.mjs --suite long",
-    "dashboard": "node scripts/control-center.mjs"
+    "dashboard": "node scripts/control-center.mjs",
+    "evals:matrix": "node scripts/eval-matrix.mjs",
+    "smoke:plain-install": "node scripts/smoke-plain-install.mjs",
+    "release:check-tag": "node scripts/check-release-tag.mjs",
+    "evals:polyglot:validate": "node scripts/validate-live-suite.mjs --suite polyglot",
+    "evals:polyglot": "node scripts/eval-live.mjs --suite polyglot",
+    "evals:matrix:gate": "node scripts/eval-matrix.mjs --require-confidence",
+    "evals:ablation": "node scripts/eval-ablation.mjs"
   },
   "keywords": [
     "opencode",

package/scripts/check-release-tag.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"))
+const explicit = process.argv[2] || process.env.GITHUB_REF_NAME || ""
+const tag = String(explicit).trim()
+
+if (!tag || !tag.startsWith("v")) {
+  console.error("[release] Refusing publish without an explicit v* release tag; package version is " + pkg.version + ".")
+  process.exit(1)
+}
+
+const expected = "v" + pkg.version
+if (tag !== expected) {
+  console.error("[release] Tag/package mismatch: tag=" + tag + ", expected=" + expected)
+  process.exit(1)
+}
+
+console.log("[release] Tag matches package version: " + tag)

package/scripts/control-center.mjs

@@ -3,6 +3,7 @@ import { createServer } from "node:http"
 import { readFile } from "node:fs/promises"
 import path from "node:path"
 import { collectControlCenterData, writeControlCenter } from "../lib/control-center.mjs"
+import { recoverStaleTasks } from "../lib/task-engine.mjs"
 
 const args = process.argv.slice(2)
 const root = path.resolve(args[0] && !args[0].startsWith("--") ? args[0] : process.cwd())
@@ -17,6 +18,30 @@ console.log("[ues] Control Center: " + result.file)
 
 if (serve) {
   const server = createServer(async (req, res) => {
+    if (req.method === "POST" && req.url === "/api/recover") {
+      let body = ""
+      for await (const chunk of req) {
+        body += chunk
+        if (body.length > 16 * 1024) {
+          res.writeHead(413)
+          res.end("request too large")
+          return
+        }
+      }
+      try {
+        const input = JSON.parse(body || "{}")
+        const result = await recoverStaleTasks(root, String(input.slug || ""))
+        res.writeHead(200, {
+          "content-type": "application/json; charset=utf-8",
+          "cache-control": "no-store",
+        })
+        res.end(JSON.stringify(result, null, 2) + "\n")
+      } catch (error) {
+        res.writeHead(400, { "content-type": "text/plain; charset=utf-8" })
+        res.end(String(error?.message || error))
+      }
+      return
+    }
     if (req.url === "/data.json") {
       const current = await collectControlCenterData(root)
       const body = JSON.stringify(current, null, 2) + "\n"

package/scripts/eval-ablation.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises"
+import path from "node:path"
+import { compareEvalSummaries } from "../lib/eval-ablation.mjs"
+
+const args = process.argv.slice(2)
+
+function option(name, fallback) {
+  const index = args.indexOf(name)
+  return index >= 0 && index + 1 < args.length ? args[index + 1] : fallback
+}
+
+function positional() {
+  const values = []
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index].startsWith("--")) {
+      if (["--pass-rate-tolerance", "--min-initial-reduction", "--max-token-ratio", "--max-duration-ratio"].includes(args[index])) index += 1
+      continue
+    }
+    values.push(args[index])
+  }
+  return values
+}
+
+const [referenceFile, candidateFile] = positional()
+if (!referenceFile || !candidateFile) {
+  console.error("Usage: node scripts/eval-ablation.mjs <reference-summary.json> <candidate-summary.json> [--require-gate] [--min-initial-reduction 0.10]")
+  process.exit(2)
+}
+
+const [reference, candidate] = await Promise.all([
+  readFile(path.resolve(referenceFile), "utf8").then(JSON.parse),
+  readFile(path.resolve(candidateFile), "utf8").then(JSON.parse),
+])
+
+const report = compareEvalSummaries(reference, candidate, {
+  passRateTolerance: Number(option("--pass-rate-tolerance", "0")),
+  minInitialInputReduction: Number(option("--min-initial-reduction", "0.10")),
+  maxTotalTokenRatio: Number(option("--max-token-ratio", "1.05")),
+  maxDurationRatio: Number(option("--max-duration-ratio", "1.10")),
+})
+
+console.log(JSON.stringify(report, null, 2))
+if (args.includes("--require-gate") && !report.gateEligible) process.exitCode = 1