opencode-agent-skill 13.0.0-beta.2 → 14.2.0-beta.1

package/global-config/skills/nestjs-engineering/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: nestjs-engineering
-description: Work on NestJS apps: modules, controllers, providers, DTO validation, guards, interceptors, persistence, and tests.
+description: "Work on NestJS apps: modules, controllers, providers, DTO validation, guards, interceptors, persistence, and tests."
 ---
 
 # Nestjs Engineering

package/global-config/skills/performance-engineering/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: performance-engineering
-description: Diagnose and improve performance using evidence: rendering, database, network, memory, caching, bundles, concurrency, and hot paths.
+description: "Diagnose and improve performance using evidence: rendering, database, network, memory, caching, bundles, concurrency, and hot paths."
 ---
 
 # Performance Engineering

package/global-config/skills/react-native-engineering/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: react-native-engineering
-description: Work on React Native/Expo apps: components, hooks, navigation, styling, APIs, native modules, Android/iOS build failures, platform behavior, and performance with version-aware verification.
+description: "Work on React Native/Expo apps: components, hooks, navigation, styling, APIs, native modules, Android/iOS build failures, platform behavior, and performance with version-aware verification."
 ---
 
 # React Native Engineering

package/global-config/skills/rest-api-design/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rest-api-design
-description: Design/review REST APIs: resources, methods, status codes, pagination, validation, errors, versioning, and idempotency.
+description: "Design/review REST APIs: resources, methods, status codes, pagination, validation, errors, versioning, and idempotency."
 ---
 
 # Rest Api Design

package/global-config/skills/ui-ux-engineering/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ui-ux-engineering
-description: Improve production UI/UX: hierarchy, responsive layout, components, forms, states, accessibility, realistic content, and design consistency.
+description: "Improve production UI/UX: hierarchy, responsive layout, components, forms, states, accessibility, realistic content, and design consistency."
 ---
 
 # Ui Ux Engineering

package/lib/adaptive-context-budget.mjs

@@ -0,0 +1,97 @@
+const ROLE_TARGETS = Object.freeze({
+  fast: {
+    architect: 8_000,
+    "plan-checker": 6_000,
+    executor: 6_000,
+    debugger: 8_000,
+    verifier: 4_500,
+    "integration-verifier": 8_000,
+    "visual-verifier": 5_000,
+    reviewer: 5_000,
+    critic: 6_000,
+    "codebase-mapper": 6_000,
+    researcher: 6_000,
+    "merge-arbiter": 8_000,
+  },
+  standard: {
+    architect: 12_000,
+    "plan-checker": 10_000,
+    executor: 11_000,
+    debugger: 14_000,
+    verifier: 8_000,
+    "integration-verifier": 12_000,
+    "visual-verifier": 8_000,
+    reviewer: 8_000,
+    critic: 10_000,
+    "codebase-mapper": 10_000,
+    researcher: 10_000,
+    "merge-arbiter": 12_000,
+  },
+  deep: {
+    architect: 30_000,
+    "plan-checker": 24_000,
+    executor: 26_000,
+    debugger: 32_000,
+    verifier: 20_000,
+    "integration-verifier": 30_000,
+    "visual-verifier": 18_000,
+    reviewer: 20_000,
+    critic: 24_000,
+    "codebase-mapper": 28_000,
+    researcher: 24_000,
+    "merge-arbiter": 30_000,
+  },
+})
+
+function clamp(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function adaptiveContextBudget(taskPolicy = {}, role = "executor", attempt = 1, options = {}) {
+  const base = clamp(
+    taskPolicy.contextBudget ?? taskPolicy.profile?.contextBudget,
+    20_000,
+    4_000,
+    48_000,
+  )
+  const profile = String(taskPolicy.executionProfile || taskPolicy.profile?.name || "standard")
+  const highRisk = taskPolicy.risk === "high" || taskPolicy.risk === "critical"
+
+  // High-risk work keeps the original evidence budget. Turbo mode must not trade
+  // away security/payment/schema evidence for latency.
+  if (highRisk || options.disabled === true) {
+    return {
+      schemaVersion: 1,
+      budget: base,
+      baseBudget: base,
+      adaptive: false,
+      reason: highRisk ? "high-risk-preserves-base-budget" : "disabled",
+    }
+  }
+
+  const table = ROLE_TARGETS[profile] || ROLE_TARGETS.standard
+  const target = clamp(table?.[role], base, 4_000, base)
+  const normalizedAttempt = Math.max(1, Math.trunc(Number(attempt || 1)))
+
+  // Failed attempts expand deterministically back toward the policy ceiling.
+  let budget = target
+  if (normalizedAttempt === 2) budget = Math.min(base, Math.max(target, Math.round(target * 1.5)))
+  else if (normalizedAttempt >= 3) budget = base
+
+  if (options.contextInsufficient === true) {
+    budget = Math.min(base, Math.max(budget, Math.round(target * 1.75)))
+  }
+
+  return {
+    schemaVersion: 1,
+    budget,
+    baseBudget: base,
+    adaptive: budget < base,
+    profile,
+    role,
+    attempt: normalizedAttempt,
+    reason: budget < base ? "role-bounded-expand-on-failure" : "policy-ceiling",
+  }
+}

package/lib/affected-tests.mjs

@@ -0,0 +1,260 @@
+import { existsSync } from "node:fs"
+import { readFile, readdir, stat } from "node:fs/promises"
+import path from "node:path"
+import { spawnSync } from "node:child_process"
+import { runtimeWorkspaceFingerprint } from "./workspace-fingerprint.mjs"
+
+const TEST_RE = /(?:^|[/.\\])(?:__tests__|tests?|spec)(?:[/.\\]|$)|\.(?:test|spec|e2e-spec)\.[cm]?[jt]sx?$/i
+const SOURCE_EXT = new Set([".js",".jsx",".mjs",".cjs",".ts",".tsx",".py",".java",".kt",".kts",".cs",".go",".rs",".dart",".swift"])
+const SKIP = new Set([".git","node_modules",".next","dist","build","coverage",".venv","venv","target","Pods","DerivedData",".gradle",".ues-cache",".ues-work",".ues-sandboxes",".ues-traces",".ues-learning",".ues-dashboard",".ues-memory",".ues-evals"])
+const AFFECTED_TEST_CACHE = new Map()
+const AFFECTED_TEST_INFLIGHT = new Map()
+
+function git(root, args) {
+  return spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 8 * 1024 * 1024 })
+}
+
+function normalize(file) {
+  return String(file || "").replaceAll("\\", "/").replace(/^\.\//, "")
+}
+
+function stem(file) {
+  return path.basename(file)
+    .replace(/\.(?:test|spec|e2e-spec)(?=\.)/i, "")
+    .replace(/\.[^.]+$/, "")
+    .toLowerCase()
+}
+
+function tokens(file) {
+  return [...new Set(normalize(file).toLowerCase().split(/[^a-z0-9]+/).filter((x) => x.length >= 3))]
+}
+
+async function walk(root, options = {}) {
+  const maxFiles = Math.max(200, Number(options.maxFiles || 6000))
+  const rows = []
+  async function visit(dir, depth) {
+    if (rows.length >= maxFiles || depth > 14) return
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      if (rows.length >= maxFiles) break
+      if (entry.isDirectory() && SKIP.has(entry.name)) continue
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) await visit(full, depth + 1)
+      else if (entry.isFile()) rows.push(full)
+    }
+  }
+  await visit(root, 0)
+  return rows
+}
+
+export function gitChangedFiles(root = process.cwd()) {
+  root = path.resolve(root)
+  const inside = git(root, ["rev-parse", "--is-inside-work-tree"])
+  if (inside.status !== 0) return []
+
+  const names = new Set()
+  for (const args of [
+    ["diff", "--name-only", "--"],
+    ["diff", "--cached", "--name-only", "--"],
+    ["ls-files", "--others", "--exclude-standard"],
+  ]) {
+    const result = git(root, args)
+    if (result.status !== 0) continue
+    for (const row of String(result.stdout || "").split(/\r?\n/)) {
+      const file = normalize(row.trim())
+      if (file) names.add(file)
+    }
+  }
+  return [...names]
+}
+
+function scoreTest(testFile, changedFile, content = "") {
+  const test = normalize(testFile).toLowerCase()
+  const changed = normalize(changedFile).toLowerCase()
+  let score = 0
+  const reasons = []
+  const changedStem = stem(changed)
+  const testStem = stem(test)
+
+  if (changedStem && testStem.includes(changedStem)) {
+    score += 35
+    reasons.push("same-stem")
+  }
+  const testDir = path.posix.dirname(test)
+  const changedDir = path.posix.dirname(changed)
+  if (testDir === changedDir) {
+    score += 20
+    reasons.push("same-directory")
+  } else if (testDir.startsWith(changedDir + "/") || changedDir.startsWith(testDir + "/")) {
+    score += 10
+    reasons.push("nearby-directory")
+  }
+
+  const changedTokens = tokens(changed)
+  const overlap = changedTokens.filter((token) => test.includes(token)).length
+  if (overlap) {
+    score += Math.min(20, overlap * 4)
+    reasons.push("path-token-overlap")
+  }
+
+  const base = path.basename(changed).replace(/\.[^.]+$/, "")
+  if (base.length >= 3 && content.toLowerCase().includes(base.toLowerCase())) {
+    score += 25
+    reasons.push("content-reference")
+  }
+
+  return { score, reasons }
+}
+
+async function nearestPackage(root, file) {
+  let dir = path.dirname(path.resolve(root, file))
+  const base = path.resolve(root)
+  while (dir === base || dir.startsWith(base + path.sep)) {
+    const packageFile = path.join(dir, "package.json")
+    if (existsSync(packageFile)) {
+      try {
+        return { dir, json: JSON.parse(await readFile(packageFile, "utf8")) }
+      } catch {}
+    }
+    if (dir === base) break
+    dir = path.dirname(dir)
+  }
+  return null
+}
+
+function packageManager(root) {
+  if (existsSync(path.join(root, "pnpm-lock.yaml"))) return "pnpm"
+  if (existsSync(path.join(root, "yarn.lock"))) return "yarn"
+  if (existsSync(path.join(root, "bun.lock")) || existsSync(path.join(root, "bun.lockb"))) return "bun"
+  return "npm"
+}
+
+function targetedCommand(root, pkg, testFile) {
+  const script = String(pkg?.json?.scripts?.test || "")
+  if (!script || !/(jest|vitest|node\s+--test|tsx\s+--test)/i.test(script)) return null
+  const manager = packageManager(root)
+  const relativeDir = normalize(path.relative(root, pkg.dir)) || "."
+  const relativeTest = normalize(path.relative(pkg.dir, path.resolve(root, testFile)))
+
+  if (manager === "pnpm") {
+    return { command: "pnpm", args: ["--dir", relativeDir, "run", "test", "--", relativeTest], confidence: "high" }
+  }
+  if (manager === "yarn") {
+    return { command: "yarn", args: ["--cwd", relativeDir, "test", relativeTest], confidence: "high" }
+  }
+  if (manager === "bun") {
+    return { command: "bun", args: ["--cwd", relativeDir, "run", "test", "--", relativeTest], confidence: "high" }
+  }
+  return { command: "npm", args: ["--prefix", relativeDir, "test", "--", relativeTest], confidence: "high" }
+}
+
+export async function resolveAffectedTests(root = process.cwd(), options = {}) {
+  root = path.resolve(root)
+  const changed = (options.changedFiles || gitChangedFiles(root))
+    .map(normalize)
+    .filter((file) => SOURCE_EXT.has(path.extname(file).toLowerCase()) && !TEST_RE.test(file))
+
+  if (!changed.length) {
+    return {
+      schemaVersion: 1,
+      root,
+      changedFiles: [],
+      tests: [],
+      suggestedCommands: [],
+      truncated: false,
+      cacheHit: false,
+    }
+  }
+
+  const limit = Math.max(1, Math.min(40, Number(options.limit || 12)))
+  let fingerprint = String(options.workspaceFingerprint || "")
+  if (!fingerprint || fingerprint === "unknown") {
+    try { fingerprint = runtimeWorkspaceFingerprint(root) } catch { fingerprint = "" }
+  }
+  if (fingerprint === "unknown") fingerprint = ""
+
+  const cacheKey = JSON.stringify([
+    root,
+    fingerprint || "no-fingerprint",
+    [...changed].sort(),
+    Number(options.maxFiles || 6000),
+    limit,
+  ])
+
+  if (fingerprint && AFFECTED_TEST_CACHE.has(cacheKey)) {
+    return { ...AFFECTED_TEST_CACHE.get(cacheKey), cacheHit: true }
+  }
+  if (fingerprint && AFFECTED_TEST_INFLIGHT.has(cacheKey)) {
+    const value = await AFFECTED_TEST_INFLIGHT.get(cacheKey)
+    return { ...value, cacheHit: true, cacheCoalesced: true }
+  }
+
+  const compute = async () => {
+    const files = await walk(root, options)
+    const tests = files
+      .map((file) => normalize(path.relative(root, file)))
+      .filter((file) => TEST_RE.test(file))
+
+    const ranked = []
+    for (const testFile of tests) {
+      const info = await stat(path.join(root, testFile)).catch(() => null)
+      const content = info?.size && info.size <= 512 * 1024
+        ? await readFile(path.join(root, testFile), "utf8").catch(() => "")
+        : ""
+      let best = { score: 0, reasons: [], changedFile: null }
+      for (const changedFile of changed) {
+        const current = scoreTest(testFile, changedFile, content)
+        if (current.score > best.score) best = { ...current, changedFile }
+      }
+      if (best.score > 0) ranked.push({ path: testFile, ...best })
+    }
+
+    ranked.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+    const selected = ranked.slice(0, limit)
+    const suggestedCommands = []
+    const seen = new Set()
+
+    for (const item of selected.slice(0, 8)) {
+      const pkg = await nearestPackage(root, item.path)
+      const command = pkg ? targetedCommand(root, pkg, item.path) : null
+      if (!command) continue
+      const key = JSON.stringify([command.command, command.args])
+      if (seen.has(key)) continue
+      seen.add(key)
+      suggestedCommands.push({ ...command, test: item.path })
+    }
+
+    return {
+      schemaVersion: 1,
+      root,
+      changedFiles: changed,
+      tests: selected,
+      suggestedCommands,
+      truncated: ranked.length > selected.length,
+      cacheHit: false,
+    }
+  }
+
+  const pending = compute()
+  if (fingerprint) AFFECTED_TEST_INFLIGHT.set(cacheKey, pending)
+
+  try {
+    const result = await pending
+    if (fingerprint) {
+      AFFECTED_TEST_CACHE.set(cacheKey, result)
+      while (AFFECTED_TEST_CACHE.size > 24) {
+        const oldest = AFFECTED_TEST_CACHE.keys().next().value
+        if (!oldest) break
+        AFFECTED_TEST_CACHE.delete(oldest)
+      }
+    }
+    return result
+  } finally {
+    if (fingerprint) AFFECTED_TEST_INFLIGHT.delete(cacheKey)
+  }
+}
+
+export function clearAffectedTestCache() {
+  AFFECTED_TEST_CACHE.clear()
+  AFFECTED_TEST_INFLIGHT.clear()
+}

package/lib/benchmark-confidence.mjs

@@ -125,8 +125,36 @@ export function pairedBenchmarkConfidence(results, options = {}) {
     initialInputAcceptable,
     tokensAcceptable,
   }
+
+  const baselineContaminated = pairs.filter((pair) => pair.baseline?.baselineIsolated === false).length
+  const baselineIsolationUnknown = pairs.filter((pair) => pair.baseline?.baselineIsolated !== true).length - baselineContaminated
+  const uesControllerUnproven = pairs.filter((pair) => pair.ues?.telemetry?.controllerUsed !== true).length
+  const uesFalsePasses = pairs.filter((pair) =>
+    pair.ues?.telemetry?.controllerPass === true &&
+    Number(pair.ues?.graderExit) !== 0
+  ).length
+  const qualityRegressionTolerance = Math.max(0, Number(options.qualityRegressionTolerance || 0))
+  const qualityNonRegression = delta >= -qualityRegressionTolerance
+  const efficiencySignals = [
+    durationRatio == null ? null : durationRatio < 1,
+    initialInputRatio == null ? null : initialInputRatio < 1,
+    tokenRatio == null ? null : tokenRatio < 1,
+  ].filter((value) => value !== null)
+  const efficiencyImproved = efficiencySignals.some(Boolean)
+  const turboChecks = {
+    pairedCoverage: total >= minPairs,
+    baselineIsolated: baselineContaminated === 0 && baselineIsolationUnknown === 0,
+    uesControllerUsed: uesControllerUnproven === 0,
+    qualityNonRegression,
+    noSuiteRegression,
+    noControllerFalsePass: uesFalsePasses === 0,
+    speedAcceptable,
+    initialInputAcceptable,
+    tokensAcceptable,
+    efficiencyImproved,
+  }
   return {
-    schemaVersion: 2,
+    schemaVersion: 3,
     kind: "ues-paired-benchmark-confidence",
     pairs: total,
     bothPass,
@@ -169,5 +197,16 @@ export function pairedBenchmarkConfidence(results, options = {}) {
     suites,
     checks,
     promotionEligible: Object.values(checks).every(Boolean),
+    turbo: {
+      policy: "quality-non-regression-with-efficiency-gain",
+      qualityRegressionTolerance,
+      baselineContaminated,
+      baselineIsolationUnknown,
+      uesControllerUnproven,
+      uesFalsePasses,
+      efficiencyImproved,
+      checks: turboChecks,
+      promotionEligible: Object.values(turboChecks).every(Boolean),
+    },
   }
-}
+}

package/lib/browser-mcp-routing.mjs

@@ -0,0 +1,166 @@
+import { inferTaskCapabilities } from "./capability-registry.mjs"
+
+const BROWSER_ROLES = new Set([
+  "executor",
+  "debugger",
+  "verifier",
+  "integration-verifier",
+  "visual-verifier",
+])
+
+const VISUAL_SIGNAL =
+  /(visual fidelity|visual regression|screenshot|figma|pixel|layout|responsive|viewport|accessibility snapshot|giao diện|\bui\b|\bcss\b|styling|kiểm tra hiển thị)/i
+
+const PROVIDER_SIGNAL =
+  /(playwright|browser automation|browser mcp|chromium|webkit|firefox)/i
+
+const BROWSER_TOOL_NAME =
+  /(^|[_:.])(browser|playwright)([_:.]|$)|^browser_|^playwright_|mcp.*(?:browser|playwright)/i
+
+const ACTION_PRIORITY = [
+  ["snapshot", 18],
+  ["screenshot", 17],
+  ["console", 16],
+  ["network", 15],
+  ["navigate", 14],
+  ["viewport", 13],
+  ["click", 12],
+  ["fill", 11],
+  ["type", 10],
+  ["select", 9],
+  ["press", 8],
+  ["wait", 7],
+  ["hover", 6],
+  ["locator", 5],
+  ["evaluate", 4],
+  ["close", 1],
+]
+
+const BLOCKED_BUILTINS = new Set([
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "bash",
+  "powershell",
+  "edit",
+  "write",
+  "ues_cli",
+  "ues_execute",
+  "ues_dispatch",
+])
+
+function textForTool(tool = {}) {
+  return [
+    tool.name,
+    tool.label,
+    tool.description,
+  ].filter(Boolean).join(" ")
+}
+
+function normalizeExplicitNames(values = []) {
+  if (typeof values === "string") values = values.split(",")
+  return [...new Set(
+    (Array.isArray(values) ? values : [])
+      .map((value) => String(value || "").trim())
+      .filter(Boolean),
+  )]
+}
+
+export function visualEvidenceNeeded(text = "") {
+  const value = String(text || "")
+  const capabilities = inferTaskCapabilities(value, { coding: true })
+  return capabilities.required.vision === true || VISUAL_SIGNAL.test(value)
+}
+
+export function browserEvidenceNeeded(text = "", role = "") {
+  const normalizedRole = String(role || "").replace(/^ues-/, "")
+  if (!BROWSER_ROLES.has(normalizedRole)) return false
+  if (normalizedRole === "visual-verifier") return true
+
+  const capabilities = inferTaskCapabilities(String(text || ""), { coding: true })
+  return (
+    capabilities.required.browser === true ||
+    capabilities.required.vision === true ||
+    VISUAL_SIGNAL.test(String(text || ""))
+  )
+}
+
+export function selectBrowserMcpToolNames(tools = [], options = {}) {
+  const limit = Math.max(1, Math.min(Number(options.limit || 14), 32))
+  const explicit = normalizeExplicitNames(options.explicitNames)
+  const rows = []
+  const available = new Map()
+
+  for (const raw of Array.isArray(tools) ? tools : []) {
+    const name = String(raw?.name || "").trim()
+    if (!name || BLOCKED_BUILTINS.has(name) || name.startsWith("ues_")) continue
+    available.set(name, raw)
+
+    const descriptor = textForTool(raw)
+    const providerHit = PROVIDER_SIGNAL.test(descriptor)
+    const nameHit = BROWSER_TOOL_NAME.test(name)
+    if (!providerHit && !nameHit) continue
+
+    let score = providerHit ? 100 : 70
+    if (/playwright/i.test(descriptor)) score += 30
+    if (/^browser_|(?:^|[_:.])browser[_:.]/i.test(name)) score += 20
+    for (const [signal, weight] of ACTION_PRIORITY) {
+      if (name.toLowerCase().includes(signal)) {
+        score += weight
+        break
+      }
+    }
+    rows.push({ name, score })
+  }
+
+  const selected = []
+  for (const name of explicit) {
+    if (available.has(name) && !selected.includes(name)) selected.push(name)
+  }
+
+  for (const row of rows.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name))) {
+    if (selected.length >= limit) break
+    if (!selected.includes(row.name)) selected.push(row.name)
+  }
+
+  return selected.slice(0, limit)
+}
+
+export function selectBrowserToolsForTask(names = [], text = "", role = "") {
+  const value = String(text || "").toLowerCase()
+  const normalizedRole = String(role || "").replace(/^ues-/, "")
+  const visual = visualEvidenceNeeded(text) || normalizedRole === "visual-verifier"
+  const interactive = /(click|fill|type|select|press|submit|login|checkout|flow|interaction|form|navigate|đăng nhập|nhấn|điền|chọn)/i.test(value)
+  const diagnostics = /(console|network|request|response|error|failed|api|socket|log)/i.test(value)
+
+  const keep = []
+  const addIf = (name, predicate) => {
+    const lower = name.toLowerCase()
+    if (predicate(lower) && !keep.includes(name)) keep.push(name)
+  }
+
+  for (const name of names) {
+    addIf(name, (lower) => /snapshot|accessibility|navigate|close/.test(lower))
+  }
+  if (visual) {
+    for (const name of names) addIf(name, (lower) => /screenshot|viewport|snapshot|accessibility/.test(lower))
+  }
+  if (interactive) {
+    for (const name of names) addIf(name, (lower) => /click|fill|type|select|press|wait|hover|locator|navigate/.test(lower))
+  }
+  if (diagnostics || normalizedRole === "verifier" || normalizedRole === "integration-verifier") {
+    for (const name of names) addIf(name, (lower) => /console|network|request|response/.test(lower))
+  }
+
+  // Keep a small escape hatch for providers whose naming does not expose action semantics.
+  if (keep.length < 3) {
+    for (const name of names) {
+      if (!keep.includes(name)) keep.push(name)
+      if (keep.length >= Math.min(6, names.length)) break
+    }
+  }
+
+  const limit = visual || interactive ? 10 : 6
+  return keep.slice(0, limit)
+}