opencode-agent-skill 10.0.0 → 11.0.0

package/lib/skill-quality.mjs

@@ -0,0 +1,72 @@
+import { existsSync } from "node:fs"
+import { readFile, readdir } from "node:fs/promises"
+import path from "node:path"
+
+function words(value) {
+  return new Set(String(value || "").toLowerCase().match(/[a-z0-9-]{3,}/g) || [])
+}
+
+function similarity(a, b) {
+  const left = words(a)
+  const right = words(b)
+  const union = new Set([...left, ...right])
+  let intersection = 0
+  for (const item of left) if (right.has(item)) intersection += 1
+  return union.size ? intersection / union.size : 0
+}
+
+function frontmatter(source) {
+  const name = source.match(/^name:\s*([^\r\n]+)/m)?.[1]?.trim() || null
+  const description = source.match(/^description:\s*([^\r\n]+)/m)?.[1]?.trim() || null
+  return { name, description }
+}
+
+export async function lintSkillCatalog(root = process.cwd(), options = {}) {
+  const skillsRoot = path.join(path.resolve(root), "global-config", "skills")
+  const entries = await readdir(skillsRoot, { withFileTypes: true })
+  const skills = []
+  const errors = []
+  const warnings = []
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    const file = path.join(skillsRoot, entry.name, "SKILL.md")
+    if (!existsSync(file)) {
+      errors.push({ skill: entry.name, issue: "missing-skill-md" })
+      continue
+    }
+    const source = await readFile(file, "utf8")
+    const meta = frontmatter(source)
+    const body = source.replace(/^---[\s\S]*?---\s*/m, "")
+    const row = {
+      id: entry.name,
+      description: meta.description,
+      chars: source.length,
+      bodyChars: body.length,
+      estimatedTokens: Math.ceil(source.length / 4),
+    }
+    skills.push(row)
+    if (meta.name !== entry.name) errors.push({ skill: entry.name, issue: "frontmatter-name-mismatch" })
+    if (!meta.description) errors.push({ skill: entry.name, issue: "missing-description" })
+    if (row.estimatedTokens > Number(options.maxSkillTokens || 1800)) warnings.push({ skill: entry.name, issue: "large-entrypoint", estimatedTokens: row.estimatedTokens })
+  }
+
+  const collisions = []
+  const threshold = Number(options.collisionThreshold || 0.58)
+  for (let i = 0; i < skills.length; i += 1) {
+    for (let j = i + 1; j < skills.length; j += 1) {
+      const score = similarity(skills[i].description, skills[j].description)
+      if (score >= threshold) collisions.push({ a: skills[i].id, b: skills[j].id, score: Number(score.toFixed(3)) })
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    valid: errors.length === 0,
+    skillCount: skills.length,
+    errors,
+    warnings,
+    collisions: collisions.sort((a, b) => b.score - a.score),
+    skills: skills.sort((a, b) => a.id.localeCompare(b.id)),
+  }
+}

package/lib/task-engine.mjs

@@ -10,6 +10,11 @@ import { validateVerificationReceipt } from "./evidence-receipt.mjs"
 import { appendRuntimeEvent, readRuntimeEvents } from "./runtime-events.mjs"
 import { createGateReceipt, validateGateReceipt } from "./gate-receipt.mjs"
 import { classifyEngineeringTask, recoveryPolicyForAttempt } from "./orchestrator-policy.mjs"
+import { planEvidenceBudget } from "./evidence-budget.mjs"
+import { putEvidence } from "./evidence-store.mjs"
+import { inferTaskCapabilities } from "./capability-registry.mjs"
+import { buildPromptEnvelope } from "./prompt-cache.mjs"
+import { externalizeContextExcerpts } from "./context-engine-v11.mjs"
 
 const WORK_DIR = ".ues-work"
 const STATE_SCHEMA = 4
@@ -1068,11 +1073,19 @@ async function buildContextPack(loaded, taskID) {
   const task = taskByID(loaded.plan, taskID)
   const spec = await readFile(loaded.paths.spec, "utf8").catch(() => "")
   const dependencyReports = {}
+  const dependencyReportRefs = {}
 
   for (const dep of task.dependsOn || []) {
     const file = path.join(loaded.paths.reports, `${dep}.md`)
     if (!existsSync(file)) continue
-    dependencyReports[dep] = (await readFile(file, "utf8")).slice(0, 12000)
+    const report = await readFile(file, "utf8")
+    dependencyReports[dep] = report.slice(0, 6000)
+    const stored = await putEvidence(loaded.paths.root, report, {
+      kind: "dependency-report",
+      source: path.relative(loaded.paths.root, file).replaceAll("\\", "/"),
+      summary: `Dependency report for ${dep}`,
+    }).catch(() => null)
+    if (stored?.ref) dependencyReportRefs[dep] = stored.ref
   }
 
   const taskText = [
@@ -1095,27 +1108,88 @@ async function buildContextPack(loaded, taskID) {
     effectiveMaxSkills: recovery.maxSkills,
     recovery,
   }
-  const contextManifest = await buildContextManifest(
+  const capabilities = inferTaskCapabilities(taskText, {
+    longContext: contextPolicy.mode === "long-horizon",
+    coding: true,
+    toolCalling: true,
+    filesystem: true,
+  })
+  const evidenceBudget = planEvidenceBudget(effectiveContextPolicy, task, capabilities.required)
+  const rawContextManifest = await buildContextManifest(
     loaded.paths.root,
     task,
     {
-      budget: recovery.contextBudget,
+      budget: evidenceBudget.total,
       strategy: recovery.contextStrategy,
+      evidenceBudget,
     },
   ).catch(() => null)
+  const externalizedContext = rawContextManifest
+    ? await externalizeContextExcerpts(loaded.paths.root, rawContextManifest, {
+        task,
+        threshold: Math.max(1800, Math.round(evidenceBudget.total * 0.12)),
+        inlineChars: Math.max(600, Math.min(1600, Math.round(evidenceBudget.total * 0.08))),
+      }).catch(() => ({ manifest: rawContextManifest, externalized: [], externalizedBytes: 0 }))
+    : { manifest: null, externalized: [], externalizedBytes: 0 }
+  const contextManifest = externalizedContext.manifest
   const learnings = await relevantAcceptedLearnings(
     loaded.paths.root,
     [task.title, task.summary, ...(task.acceptance || [])].join(" "),
   ).catch(() => [])
 
+  const specStored = spec
+    ? await putEvidence(loaded.paths.root, spec, {
+        kind: "work-spec",
+        source: path.relative(loaded.paths.root, loaded.paths.spec).replaceAll("\\", "/"),
+        summary: "Durable work specification",
+      }).catch(() => null)
+    : null
+  const promptEnvelope = buildPromptEnvelope({
+    role: "executor",
+    invariants: "evidence-first; scoped edits; fresh verification; no unsupported completion claims",
+    skills: contextPolicy.domains || [],
+    projectFacts: {
+      instructions: contextManifest?.instructions || [],
+      strategy: recovery.contextStrategy,
+    },
+    task,
+    evidence: [
+      ...(specStored?.ref ? [specStored.ref] : []),
+      ...Object.values(dependencyReportRefs),
+      ...(contextManifest?.evidencePointers || []).map((item) => item.ref),
+      ...(contextManifest?.rankedReferences || []).slice(0, 12).map((item) => item.path),
+    ],
+    recentFailure: recovery.stage === "initial" ? null : loaded.state.tasks?.[taskID]?.lastError || null,
+    nextAction: loaded.state.checkpoint?.nextAction || loaded.state.nextAction || null,
+  })
+
   return {
     schemaVersion: STATE_SCHEMA,
+    contextSchemaVersion: 6,
     contextPolicy: effectiveContextPolicy,
+    capabilities,
+    evidenceBudget,
+    promptCache: {
+      stablePrefixHash: promptEnvelope.stablePrefixHash,
+      dynamicHash: promptEnvelope.dynamicHash,
+      stableChars: promptEnvelope.stableChars,
+      dynamicChars: promptEnvelope.dynamicChars,
+      cacheableRatio: promptEnvelope.cacheableRatio,
+    },
     attempt,
     slug: loaded.state.slug,
     task,
     taskBrief: path.relative(loaded.paths.root, path.join(loaded.paths.tasks, `${taskID}.md`)).replaceAll("\\", "/"),
-    spec: spec.slice(0, 24000),
+    spec: spec.slice(0, Math.min(12000, evidenceBudget.buckets.instructions + evidenceBudget.buckets.task)),
+    evidencePointers: {
+      spec: specStored?.ref || null,
+      dependencyReports: dependencyReportRefs,
+      context: (contextManifest?.evidencePointers || []).map((item) => item.ref),
+    },
+    evidenceStore: {
+      refs: externalizedContext.externalized.length,
+      externalizedBytes: externalizedContext.externalizedBytes,
+    },
     dependencyReports,
     decisions: loaded.state.decisions || [],
     blockers: loaded.state.blockers || [],

package/lib/ui-inspector.mjs

@@ -0,0 +1,152 @@
+function uniq(values) {
+  return [...new Set(values.filter((value) => value !== null && value !== undefined && value !== ""))]
+}
+
+function round(value, digits = 3) {
+  const factor = 10 ** digits
+  return Math.round(Number(value) * factor) / factor
+}
+
+function normalizeBox(item = {}) {
+  const box = item.box && typeof item.box === "object" ? item.box : item
+  const x = Number(box.x)
+  const y = Number(box.y)
+  const width = Number(box.width)
+  const height = Number(box.height)
+  if (![x,y,width,height].every(Number.isFinite)) return null
+  return {
+    id: String(item.id || item.name || "").trim() || null,
+    role: item.role || null,
+    x, y, width, height,
+    right: x + width,
+    bottom: y + height,
+  }
+}
+
+function containsBox(a, b) {
+  return a.x <= b.x && a.y <= b.y && a.right >= b.right && a.bottom >= b.bottom
+}
+
+function intersectionArea(a, b) {
+  const width = Math.max(0, Math.min(a.right, b.right) - Math.max(a.x, b.x))
+  const height = Math.max(0, Math.min(a.bottom, b.bottom) - Math.max(a.y, b.y))
+  return width * height
+}
+
+export function inspectResponsiveLayout(items = [], viewport = {}, options = {}) {
+  const width = Math.max(1, Number(viewport.width || 0))
+  const height = Math.max(1, Number(viewport.height || 0))
+  const boxes = items.map(normalizeBox).filter(Boolean)
+  const issues = []
+  const minTouch = Math.max(1, Number(options.minTouchTarget || 44))
+  const touchRoles = new Set(["button","link","checkbox","radio","switch","tab","menuitem"])
+
+  for (const box of boxes) {
+    if (box.x < 0 || box.y < 0 || box.right > width || box.bottom > height) {
+      issues.push({
+        kind: "viewport-overflow",
+        id: box.id,
+        box,
+        viewport: { width, height },
+      })
+    }
+    if (touchRoles.has(String(box.role || "").toLowerCase()) && (box.width < minTouch || box.height < minTouch)) {
+      issues.push({
+        kind: "small-touch-target",
+        id: box.id,
+        role: box.role,
+        actual: { width: box.width, height: box.height },
+        minimum: minTouch,
+      })
+    }
+  }
+
+  const maxPairChecks = Math.max(0, Math.min(10000, Number(options.maxPairChecks || 3000)))
+  let checks = 0
+  for (let i = 0; i < boxes.length; i += 1) {
+    for (let j = i + 1; j < boxes.length && checks < maxPairChecks; j += 1) {
+      checks += 1
+      const a = boxes[i]
+      const b = boxes[j]
+      if (containsBox(a,b) || containsBox(b,a)) continue
+      const area = intersectionArea(a,b)
+      if (!area) continue
+      const smaller = Math.max(1, Math.min(a.width*a.height, b.width*b.height))
+      const ratio = area / smaller
+      if (ratio >= Number(options.overlapRatio ?? 0.15)) {
+        issues.push({
+          kind: "element-overlap",
+          a: a.id,
+          b: b.id,
+          intersectionArea: area,
+          smallerElementRatio: round(ratio),
+        })
+      }
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    viewport: { width, height },
+    elementCount: boxes.length,
+    pairChecks: checks,
+    verdict: issues.length ? "FAIL" : "PASS",
+    issues,
+  }
+}
+
+function normalizeCssValue(value) {
+  return String(value || "").trim().replace(/\s+/g, " ")
+}
+
+export function extractDesignTokens(css = "") {
+  const source = String(css || "")
+  const variables = {}
+  for (const match of source.matchAll(/--([a-zA-Z0-9_-]+)\s*:\s*([^;}{]+)\s*;/g)) {
+    variables["--" + match[1]] = normalizeCssValue(match[2])
+  }
+
+  const colors = uniq([
+    ...source.matchAll(/#[0-9a-fA-F]{3,8}\b/g),
+    ...source.matchAll(/\b(?:rgb|rgba|hsl|hsla)\([^)]*\)/g),
+  ].map((match) => match[0].toLowerCase())).slice(0, 128)
+
+  const lengths = uniq([...source.matchAll(/-?\d*\.?\d+(?:px|rem|em)\b/g)].map((m)=>m[0]))
+  const px = lengths.filter((value)=>value.endsWith("px")).map((value)=>Number.parseFloat(value)).filter((value)=>Number.isFinite(value) && value >= 0)
+  const radii = uniq([...source.matchAll(/border-radius\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+  const fontSizes = uniq([...source.matchAll(/font-size\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+  const shadows = uniq([...source.matchAll(/box-shadow\s*:\s*([^;}{]+)/g)].map((m)=>normalizeCssValue(m[1]))).slice(0,64)
+
+  const spacingCandidates = uniq(px.filter((value)=>value <= 128).sort((a,b)=>a-b)).slice(0,32)
+
+  return {
+    schemaVersion: 1,
+    variables,
+    colors,
+    spacingCandidates,
+    radii,
+    fontSizes,
+    shadows,
+    stats: {
+      variableCount: Object.keys(variables).length,
+      colorCount: colors.length,
+      lengthCount: lengths.length,
+    },
+  }
+}
+
+export function designTokenEvidence(tokens = {}) {
+  const variableEntries = Object.entries(tokens.variables || {})
+  return {
+    schemaVersion: 1,
+    summary: {
+      variables: variableEntries.slice(0,40),
+      colors: (tokens.colors || []).slice(0,24),
+      spacingCandidates: (tokens.spacingCandidates || []).slice(0,20),
+      radii: (tokens.radii || []).slice(0,16),
+      fontSizes: (tokens.fontSizes || []).slice(0,16),
+      shadows: (tokens.shadows || []).slice(0,12),
+    },
+    stats: tokens.stats || {},
+  }
+}

package/lib/v11-metrics.mjs

@@ -0,0 +1,64 @@
+function finite(value) {
+  const n = Number(value)
+  return Number.isFinite(n) ? n : 0
+}
+
+function ratio(numerator, denominator) {
+  return denominator > 0 ? numerator / denominator : null
+}
+
+export function summarizeV11Efficiency(samples = []) {
+  const totals = {
+    samples: samples.length,
+    stableChars: 0,
+    dynamicChars: 0,
+    repeatedStableChars: 0,
+    externalizedEvidenceBytes: 0,
+    evidenceRefs: 0,
+    visualRepairAttempts: 0,
+    contextExpansions: 0,
+    modelEscalations: 0,
+    duplicateToolBlocks: 0,
+    loopBlocks: 0,
+  }
+
+  for (const sample of samples) {
+    const cache = sample.promptCache || sample.contextPack?.promptCache || {}
+    totals.stableChars += finite(cache.stableChars)
+    totals.dynamicChars += finite(cache.dynamicChars)
+    totals.repeatedStableChars += finite(sample.repeatedStableChars ?? cache.repeatedStableChars)
+
+    const evidence = sample.evidenceStore || sample.evidence || {}
+    totals.externalizedEvidenceBytes += finite(evidence.externalizedBytes ?? evidence.bytes)
+    totals.evidenceRefs += finite(evidence.refs ?? sample.evidenceRefs)
+
+    totals.visualRepairAttempts += finite(sample.visualRepairAttempts)
+    totals.contextExpansions += finite(sample.contextExpansions)
+    totals.modelEscalations += finite(sample.modelEscalations)
+    totals.duplicateToolBlocks += finite(sample.duplicateToolBlocks)
+    totals.loopBlocks += finite(sample.loopBlocks)
+  }
+
+  const inputChars = totals.stableChars + totals.dynamicChars
+  return {
+    schemaVersion: 1,
+    totals,
+    cacheablePrefixRatio: ratio(totals.stableChars, inputChars),
+    repeatedStableRatio: ratio(totals.repeatedStableChars, totals.stableChars),
+    externalizedEvidenceBytesPerSample: ratio(totals.externalizedEvidenceBytes, totals.samples),
+    evidenceRefsPerSample: ratio(totals.evidenceRefs, totals.samples),
+    visualRepairsPerSample: ratio(totals.visualRepairAttempts, totals.samples),
+    contextExpansionsPerSample: ratio(totals.contextExpansions, totals.samples),
+    modelEscalationsPerSample: ratio(totals.modelEscalations, totals.samples),
+  }
+}
+
+export function verifiedSuccessPer100kTokens(results = []) {
+  let success = 0
+  let tokens = 0
+  for (const item of results) {
+    if (item.passed === true && item.verified !== false) success += 1
+    tokens += finite(item.tokens ?? item.telemetry?.tokens?.total)
+  }
+  return tokens > 0 ? success / (tokens / 100_000) : null
+}

package/lib/visual-spec.mjs

@@ -0,0 +1,159 @@
+function number(value, fallback = 0) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+function range(value, tolerance = 0) {
+  if (Array.isArray(value) && value.length >= 2) return [number(value[0]), number(value[1])]
+  const exact = number(value)
+  return [exact - tolerance, exact + tolerance]
+}
+
+function within(actual, expected, tolerance) {
+  const [min, max] = range(expected, tolerance)
+  return actual >= Math.min(min, max) && actual <= Math.max(min, max)
+}
+
+function normalizeElement(item = {}) {
+  return {
+    id: String(item.id || "").trim(),
+    role: item.role || null,
+    region: item.region || null,
+    expected: {
+      ...(item.expected || {}),
+      ...(item.x !== undefined ? { x: item.x } : {}),
+      ...(item.y !== undefined ? { y: item.y } : {}),
+      ...(item.width !== undefined ? { width: item.width } : {}),
+      ...(item.height !== undefined ? { height: item.height } : {}),
+    },
+    tolerance: {
+      position: number(item.tolerance?.position, 8),
+      size: number(item.tolerance?.size, 8),
+    },
+    required: item.required !== false,
+  }
+}
+
+export function normalizeVisualSpec(spec = {}) {
+  const viewport = {
+    width: Math.max(1, number(spec.viewport?.width, 1440)),
+    height: Math.max(1, number(spec.viewport?.height, 900)),
+    deviceScaleFactor: Math.max(0.1, number(spec.viewport?.deviceScaleFactor, 1)),
+  }
+  return {
+    schemaVersion: 1,
+    name: spec.name || null,
+    viewport,
+    elements: (spec.elements || []).map(normalizeElement).filter((item) => item.id),
+    regions: Array.isArray(spec.regions) ? spec.regions : [],
+    tokens: spec.tokens || {},
+    metadata: spec.metadata || {},
+  }
+}
+
+export function validateVisualSpec(spec = {}) {
+  const normalized = normalizeVisualSpec(spec)
+  const errors = []
+  const ids = new Set()
+  for (const item of normalized.elements) {
+    if (ids.has(item.id)) errors.push("duplicate element id: " + item.id)
+    ids.add(item.id)
+    for (const key of ["x", "y", "width", "height"]) {
+      if (item.expected[key] === undefined) continue
+      const values = Array.isArray(item.expected[key]) ? item.expected[key] : [item.expected[key]]
+      if (values.some((value) => !Number.isFinite(Number(value)))) errors.push(item.id + ": invalid " + key)
+    }
+  }
+  return { valid: errors.length === 0, errors, spec: normalized }
+}
+
+function actualMap(actual = []) {
+  const values = Array.isArray(actual) ? actual : Object.values(actual || {})
+  return new Map(values.filter((item) => item?.id).map((item) => [String(item.id), item]))
+}
+
+export function createGeometryReceipt(specInput, actualInput, options = {}) {
+  const checked = validateVisualSpec(specInput)
+  if (!checked.valid) throw new Error("Invalid visual spec: " + checked.errors.join("; "))
+  const actual = actualMap(actualInput)
+  const elements = []
+  let failed = 0
+
+  for (const expected of checked.spec.elements) {
+    const found = actual.get(expected.id)
+    if (!found) {
+      const pass = !expected.required
+      if (!pass) failed += 1
+      elements.push({ id: expected.id, verdict: pass ? "PASS" : "FAIL", reason: "missing", expected: expected.expected, actual: null })
+      continue
+    }
+
+    const failures = []
+    const checks = {}
+    for (const key of ["x", "y"]) {
+      if (expected.expected[key] === undefined) continue
+      const ok = within(number(found[key]), expected.expected[key], expected.tolerance.position)
+      checks[key] = ok
+      if (!ok) failures.push(key)
+    }
+    for (const key of ["width", "height"]) {
+      if (expected.expected[key] === undefined) continue
+      const ok = within(number(found[key]), expected.expected[key], expected.tolerance.size)
+      checks[key] = ok
+      if (!ok) failures.push(key)
+    }
+    const pass = failures.length === 0
+    if (!pass) failed += 1
+    elements.push({
+      id: expected.id,
+      verdict: pass ? "PASS" : "FAIL",
+      failures,
+      checks,
+      expected: expected.expected,
+      actual: {
+        x: number(found.x),
+        y: number(found.y),
+        width: number(found.width),
+        height: number(found.height),
+      },
+    })
+  }
+
+  return {
+    schemaVersion: 1,
+    kind: "visual-geometry",
+    verdict: failed === 0 ? "PASS" : "FAIL",
+    viewport: checked.spec.viewport,
+    total: elements.length,
+    passed: elements.length - failed,
+    failed,
+    elements,
+    generatedAt: options.generatedAt || new Date().toISOString(),
+  }
+}
+
+export function buildVisualRepairPlan(receipt, pixelDiff = null) {
+  const failedElements = (receipt?.elements || []).filter((item) => item.verdict !== "PASS")
+  return {
+    schemaVersion: 1,
+    action: failedElements.length || (pixelDiff && pixelDiff.differentPixels > 0) ? "repair" : "accept",
+    failedElementIDs: failedElements.map((item) => item.id),
+    geometryFailures: failedElements.map((item) => ({ id: item.id, failures: item.failures || [item.reason] })),
+    pixelRegion: pixelDiff?.bounds || null,
+    directives: [
+      ...(failedElements.length ? ["edit only the owning component/style for failed geometry unless evidence shows a shared token defect"] : []),
+      ...(pixelDiff?.bounds ? ["inspect and, if vision is available, crop only the largest changed pixel region before another edit"] : []),
+      "re-render the affected viewport and produce a fresh receipt before declaring success",
+    ],
+  }
+}
+
+export function responsiveViewportMatrix(input = null) {
+  if (Array.isArray(input) && input.length) return input
+  return [
+    { id: "mobile", width: 390, height: 844 },
+    { id: "tablet", width: 768, height: 1024 },
+    { id: "desktop", width: 1440, height: 900 },
+    { id: "wide", width: 1920, height: 1080 },
+  ]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-agent-skill",
-  "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",
+  "version": "11.0.0",
+  "description": "Perception-aware evidence-first engineering runtime with adaptive context, capability routing, visual/browser verification, weak-model recovery and benchmark-gated execution 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 run evals:polyglot:validate && npm test && npm pack --dry-run && npm run smoke:pack && npm run smoke:plain-install",
+    "ci": "npm run syntax && npm run validate && npm run evals && npm run evals:router && npm run evals:v11:validate && 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",
@@ -46,7 +46,9 @@
     "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"
+    "evals:ablation": "node scripts/eval-ablation.mjs",
+    "evals:v11": "node --test test/*-v11.test.mjs",
+    "evals:v11:validate": "node scripts/validate-v11-suite.mjs"
   },
   "keywords": [
     "opencode",
@@ -56,7 +58,10 @@
     "engineering-workflow",
     "code-review",
     "debugging",
-    "verification"
+    "verification",
+    "visual-testing",
+    "browser-automation",
+    "multimodal-agents"
   ],
   "engines": {
     "node": ">=20"

package/scripts/eval-ablation.mjs

@@ -14,7 +14,7 @@ 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
+      if (["--pass-rate-tolerance", "--min-initial-reduction", "--max-token-ratio", "--max-duration-ratio", "--min-cacheable-ratio", "--min-evidence-reuse-ratio", "--max-repeated-stable-ratio"].includes(args[index])) index += 1
       continue
     }
     values.push(args[index])
@@ -38,6 +38,9 @@ const report = compareEvalSummaries(reference, candidate, {
   minInitialInputReduction: Number(option("--min-initial-reduction", "0.10")),
   maxTotalTokenRatio: Number(option("--max-token-ratio", "1.05")),
   maxDurationRatio: Number(option("--max-duration-ratio", "1.10")),
+  minCacheableRatio: option("--min-cacheable-ratio", null) == null ? null : Number(option("--min-cacheable-ratio", null)),
+  minEvidenceReuseRatio: option("--min-evidence-reuse-ratio", null) == null ? null : Number(option("--min-evidence-reuse-ratio", null)),
+  maxRepeatedStableRatio: option("--max-repeated-stable-ratio", null) == null ? null : Number(option("--max-repeated-stable-ratio", null)),
 })
 
 console.log(JSON.stringify(report, null, 2))