opencode-agent-skill 10.0.0 → 12.0.0-beta.0

package/lib/eval-report.mjs

@@ -14,6 +14,20 @@ export function summarizeEvalResults(results) {
       initialInputSamples: 0,
       cost: 0,
       costSamples: 0,
+      cacheableRatio: 0,
+      cacheableRatioSamples: 0,
+      repeatedStableChars: 0,
+      repeatedStableSamples: 0,
+      repeatedStableRatio: 0,
+      repeatedStableRatioSamples: 0,
+      evidenceReuseRatio: 0,
+      evidenceReuseSamples: 0,
+      visualRepairAttempts: 0,
+      visualRepairSamples: 0,
+      contextExpansions: 0,
+      contextExpansionSamples: 0,
+      modelEscalations: 0,
+      modelEscalationSamples: 0,
     }
     bucket.total += 1
     if (item.passed) bucket.passed += 1
@@ -36,6 +50,36 @@ export function summarizeEvalResults(results) {
       bucket.cost += Number(item.telemetry?.cost) || 0
       bucket.costSamples += 1
     }
+
+    const v11 = item.telemetry?.v11 || {}
+    if (Number.isFinite(Number(v11.avgCacheableRatio))) {
+      bucket.cacheableRatio += Number(v11.avgCacheableRatio)
+      bucket.cacheableRatioSamples += 1
+    }
+    if (Number.isFinite(Number(v11.repeatedStableChars))) {
+      bucket.repeatedStableChars += Number(v11.repeatedStableChars)
+      bucket.repeatedStableSamples += 1
+    }
+    if (Number.isFinite(Number(v11.repeatedStableRatio))) {
+      bucket.repeatedStableRatio += Number(v11.repeatedStableRatio)
+      bucket.repeatedStableRatioSamples += 1
+    }
+    if (Number.isFinite(Number(v11.evidenceReuseRatio))) {
+      bucket.evidenceReuseRatio += Number(v11.evidenceReuseRatio)
+      bucket.evidenceReuseSamples += 1
+    }
+    if (Number.isFinite(Number(v11.visualRepairAttempts))) {
+      bucket.visualRepairAttempts += Number(v11.visualRepairAttempts)
+      bucket.visualRepairSamples += 1
+    }
+    if (Number.isFinite(Number(v11.contextExpansions))) {
+      bucket.contextExpansions += Number(v11.contextExpansions)
+      bucket.contextExpansionSamples += 1
+    }
+    if (Number.isFinite(Number(v11.modelEscalations))) {
+      bucket.modelEscalations += Number(v11.modelEscalations)
+      bucket.modelEscalationSamples += 1
+    }
   }
 
   for (const bucket of Object.values(modes)) {
@@ -45,11 +89,25 @@ export function summarizeEvalResults(results) {
     bucket.avgTokens = bucket.tokenSamples ? bucket.tokens / bucket.tokenSamples : null
     bucket.avgInitialInputTokens = bucket.initialInputSamples ? bucket.initialInputTokens / bucket.initialInputSamples : null
     bucket.avgCost = bucket.costSamples ? bucket.cost / bucket.costSamples : null
+    bucket.avgCacheableRatio = bucket.cacheableRatioSamples ? bucket.cacheableRatio / bucket.cacheableRatioSamples : null
+    bucket.avgRepeatedStableChars = bucket.repeatedStableSamples ? bucket.repeatedStableChars / bucket.repeatedStableSamples : null
+    bucket.avgRepeatedStableRatio = bucket.repeatedStableRatioSamples ? bucket.repeatedStableRatio / bucket.repeatedStableRatioSamples : null
+    bucket.avgEvidenceReuseRatio = bucket.evidenceReuseSamples ? bucket.evidenceReuseRatio / bucket.evidenceReuseSamples : null
+    bucket.avgVisualRepairAttempts = bucket.visualRepairSamples ? bucket.visualRepairAttempts / bucket.visualRepairSamples : null
+    bucket.avgContextExpansions = bucket.contextExpansionSamples ? bucket.contextExpansions / bucket.contextExpansionSamples : null
+    bucket.avgModelEscalations = bucket.modelEscalationSamples ? bucket.modelEscalations / bucket.modelEscalationSamples : null
     bucket.telemetryCoverage = {
       tools: bucket.total ? bucket.toolSamples / bucket.total : 0,
       tokens: bucket.total ? bucket.tokenSamples / bucket.total : 0,
       initialInputTokens: bucket.total ? bucket.initialInputSamples / bucket.total : 0,
       cost: bucket.total ? bucket.costSamples / bucket.total : 0,
+      cacheableRatio: bucket.total ? bucket.cacheableRatioSamples / bucket.total : 0,
+      repeatedStableChars: bucket.total ? bucket.repeatedStableSamples / bucket.total : 0,
+      repeatedStableRatio: bucket.total ? bucket.repeatedStableRatioSamples / bucket.total : 0,
+      evidenceReuseRatio: bucket.total ? bucket.evidenceReuseSamples / bucket.total : 0,
+      visualRepairAttempts: bucket.total ? bucket.visualRepairSamples / bucket.total : 0,
+      contextExpansions: bucket.total ? bucket.contextExpansionSamples / bucket.total : 0,
+      modelEscalations: bucket.total ? bucket.modelEscalationSamples / bucket.total : 0,
     }
     delete bucket.durationMs
     delete bucket.toolCalls
@@ -60,6 +118,20 @@ export function summarizeEvalResults(results) {
     delete bucket.initialInputSamples
     delete bucket.cost
     delete bucket.costSamples
+    delete bucket.cacheableRatio
+    delete bucket.cacheableRatioSamples
+    delete bucket.repeatedStableChars
+    delete bucket.repeatedStableSamples
+    delete bucket.repeatedStableRatio
+    delete bucket.repeatedStableRatioSamples
+    delete bucket.evidenceReuseRatio
+    delete bucket.evidenceReuseSamples
+    delete bucket.visualRepairAttempts
+    delete bucket.visualRepairSamples
+    delete bucket.contextExpansions
+    delete bucket.contextExpansionSamples
+    delete bucket.modelEscalations
+    delete bucket.modelEscalationSamples
   }
 
   const byTaskMap = new Map()

package/lib/eval-telemetry.mjs

@@ -93,6 +93,18 @@ export function parseOpenCodeTelemetry(stdout) {
   let usageSamples = 0
   let costSamples = 0
   let firstUsage = null
+  const v11 = {
+    promptCacheSamples: 0,
+    cacheableRatioSum: 0,
+    stableChars: 0,
+    dynamicChars: 0,
+    repeatedStableChars: 0,
+    evidenceRefs: new Set(),
+    evidenceRefOccurrences: 0,
+    visualRepairAttempts: 0,
+    contextExpansions: 0,
+    modelEscalations: 0,
+  }
 
   parsed.forEach((event, eventIndex) => {
     let eventUsage = null
@@ -120,6 +132,39 @@ export function parseOpenCodeTelemetry(stdout) {
       }
 
       if (!eventUsage) eventUsage = usageFromObject(object)
+
+      const promptCache = object.promptCache && typeof object.promptCache === "object" ? object.promptCache : null
+      if (promptCache) {
+        const ratio = Number(promptCache.cacheableRatio)
+        if (Number.isFinite(ratio)) {
+          v11.promptCacheSamples += 1
+          v11.cacheableRatioSum += ratio
+        }
+        const stableChars = Number(promptCache.stableChars)
+        if (Number.isFinite(stableChars) && stableChars >= 0) v11.stableChars += stableChars
+        const dynamicChars = Number(promptCache.dynamicChars)
+        if (Number.isFinite(dynamicChars) && dynamicChars >= 0) v11.dynamicChars += dynamicChars
+        const repeated = Number(promptCache.repeatedStableChars)
+        if (Number.isFinite(repeated) && repeated >= 0) v11.repeatedStableChars += repeated
+      }
+
+      const scanRefs = (value) => {
+        if (typeof value === "string" && /^evidence:sha256:[a-f0-9]{64}$/i.test(value)) {
+          v11.evidenceRefOccurrences += 1
+          v11.evidenceRefs.add(value.toLowerCase())
+        } else if (Array.isArray(value)) {
+          for (const item of value) scanRefs(item)
+        } else if (value && typeof value === "object") {
+          for (const child of Object.values(value)) scanRefs(child)
+        }
+      }
+      scanRefs(object.evidencePointers)
+      scanRefs(object.evidence)
+
+      const eventName = String(object.type || object.event || object.kind || "").toLowerCase()
+      if (eventName.includes("visual") && eventName.includes("repair")) v11.visualRepairAttempts += 1
+      if (eventName.includes("context") && (eventName.includes("expand") || eventName.includes("recovery"))) v11.contextExpansions += 1
+      if (eventName.includes("model") && eventName.includes("escalat")) v11.modelEscalations += 1
       if (eventCost === null) {
         for (const key of ["cost", "totalCost", "total_cost"]) {
           if (typeof object[key] === "number" && Number.isFinite(object[key])) {
@@ -157,5 +202,21 @@ export function parseOpenCodeTelemetry(stdout) {
     usageSamples,
     cost,
     costSamples,
+    v11: {
+      promptCacheSamples: v11.promptCacheSamples,
+      avgCacheableRatio: v11.promptCacheSamples ? v11.cacheableRatioSum / v11.promptCacheSamples : null,
+      avgStableChars: v11.promptCacheSamples ? v11.stableChars / v11.promptCacheSamples : null,
+      avgDynamicChars: v11.promptCacheSamples ? v11.dynamicChars / v11.promptCacheSamples : null,
+      repeatedStableChars: v11.promptCacheSamples ? v11.repeatedStableChars : null,
+      repeatedStableRatio: v11.stableChars > 0 ? v11.repeatedStableChars / v11.stableChars : null,
+      evidenceRefOccurrences: v11.evidenceRefOccurrences || null,
+      uniqueEvidenceRefs: v11.evidenceRefs.size || null,
+      evidenceReuseRatio: v11.evidenceRefOccurrences
+        ? 1 - (v11.evidenceRefs.size / v11.evidenceRefOccurrences)
+        : null,
+      visualRepairAttempts: v11.visualRepairAttempts || null,
+      contextExpansions: v11.contextExpansions || null,
+      modelEscalations: v11.modelEscalations || null,
+    },
   }
 }

package/lib/evidence-budget.mjs

@@ -0,0 +1,84 @@
+const DEFAULT_WEIGHTS = {
+  instructions: 0.10,
+  task: 0.08,
+  declared: 0.34,
+  tests: 0.15,
+  references: 0.20,
+  history: 0.05,
+  tools: 0.08,
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value))
+}
+
+function normalizeWeights(weights) {
+  const total = Object.values(weights).reduce((sum, value) => sum + Math.max(0, Number(value) || 0), 0) || 1
+  return Object.fromEntries(Object.entries(weights).map(([key, value]) => [key, Math.max(0, Number(value) || 0) / total]))
+}
+
+export function planEvidenceBudget(taskPolicy = {}, task = {}, signals = {}) {
+  const base = clamp(
+    Number(taskPolicy.contextBudget ?? taskPolicy.profile?.contextBudget ?? signals.contextBudget ?? 20_000),
+    4_000,
+    48_000,
+  )
+  const text = [task?.title, task?.summary, ...(task?.acceptance || [])].filter(Boolean).join(" ").toLowerCase()
+  const visual = signals.visual === true || signals.vision === true || /(screenshot|figma|visual|pixel|layout|giao diện|hình ảnh|ảnh mẫu)/i.test(text)
+  const browser = signals.browser === true || /(browser|playwright|e2e|click|navigation|trình duyệt)/i.test(text)
+  const debugging = signals.debugging === true || /(fix|bug|error|regression|debug|lỗi)/i.test(text)
+  const highRisk = taskPolicy.risk === "high"
+
+  const weights = { ...DEFAULT_WEIGHTS }
+  if (debugging) {
+    weights.tests += 0.07
+    weights.references -= 0.04
+    weights.history += 0.02
+    weights.declared -= 0.05
+  }
+  if (highRisk) {
+    weights.tests += 0.06
+    weights.references += 0.04
+    weights.tools -= 0.03
+    weights.declared -= 0.05
+    weights.task -= 0.02
+  }
+  if (visual || browser) {
+    weights.tools += 0.08
+    weights.references -= 0.04
+    weights.declared -= 0.04
+  }
+
+  const normalized = normalizeWeights(weights)
+  const buckets = Object.fromEntries(
+    Object.entries(normalized).map(([key, weight]) => [key, Math.max(256, Math.round(base * weight))]),
+  )
+  const allocated = Object.values(buckets).reduce((sum, value) => sum + value, 0)
+  const drift = base - allocated
+  buckets.declared = Math.max(256, buckets.declared + drift)
+
+  return {
+    schemaVersion: 1,
+    total: base,
+    unit: "characters",
+    buckets,
+    signals: { visual, browser, debugging, highRisk },
+    expansion: {
+      initial: base,
+      diagnose: Math.min(48_000, Math.max(base, Math.round(base * 1.35))),
+      deepRecovery: Math.min(48_000, Math.max(20_000, Math.round(base * 1.75))),
+    },
+  }
+}
+
+export function bucketLimit(plan, role, remaining = Infinity) {
+  const limit = Number(plan?.buckets?.[role] || 0)
+  return Math.max(0, Math.min(limit, Number.isFinite(remaining) ? remaining : limit))
+}
+
+export function evidenceValueScore({ relevance = 0, freshness = 0, confidence = 0, chars = 1 } = {}) {
+  const signal = Math.max(0, Number(relevance)) * 0.55 +
+    Math.max(0, Number(freshness)) * 0.20 +
+    Math.max(0, Number(confidence)) * 0.25
+  return signal / Math.max(1, Number(chars))
+}

package/lib/evidence-store.mjs

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto"
+import { existsSync } from "node:fs"
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises"
+import path from "node:path"
+
+const STORE_VERSION = 1
+const REF_PREFIX = "evidence:sha256:"
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue)
+  if (!value || typeof value !== "object" || Buffer.isBuffer(value)) return value
+  return Object.fromEntries(
+    Object.keys(value).sort().map((key) => [key, stableValue(value[key])]),
+  )
+}
+
+function toBytes(value, options = {}) {
+  if (Buffer.isBuffer(value)) return { bytes: value, encoding: "binary", mediaType: options.mediaType || "application/octet-stream" }
+  if (typeof value === "string") return { bytes: Buffer.from(value, "utf8"), encoding: "utf8", mediaType: options.mediaType || "text/plain; charset=utf-8" }
+  const text = JSON.stringify(stableValue(value), null, options.pretty === false ? 0 : 2)
+  return { bytes: Buffer.from(text, "utf8"), encoding: "utf8", mediaType: options.mediaType || "application/json" }
+}
+
+function normalizeHash(ref) {
+  const value = String(ref || "").trim()
+  const hash = value.startsWith(REF_PREFIX) ? value.slice(REF_PREFIX.length) : value.replace(/^sha256:/, "")
+  if (!/^[a-f0-9]{64}$/i.test(hash)) throw new Error("Invalid evidence reference")
+  return hash.toLowerCase()
+}
+
+export function evidenceReference(hash) {
+  return REF_PREFIX + normalizeHash(hash)
+}
+
+export function evidenceStoreRoot(root = process.cwd()) {
+  return path.join(path.resolve(root), ".ues-cache", "evidence-v1")
+}
+
+function evidencePaths(root, hash) {
+  const normalized = normalizeHash(hash)
+  const dir = path.join(evidenceStoreRoot(root), normalized.slice(0, 2))
+  return {
+    dir,
+    meta: path.join(dir, normalized + ".json"),
+    data: path.join(dir, normalized + ".blob"),
+  }
+}
+
+export async function putEvidence(root, value, options = {}) {
+  root = path.resolve(root)
+  const encoded = toBytes(value, options)
+  const hash = createHash("sha256").update(encoded.bytes).digest("hex")
+  const target = evidencePaths(root, hash)
+  await mkdir(target.dir, { recursive: true })
+
+  const now = new Date().toISOString()
+  const existing = existsSync(target.meta)
+    ? JSON.parse(await readFile(target.meta, "utf8").catch(() => "{}"))
+    : null
+
+  if (!existsSync(target.data)) await writeFile(target.data, encoded.bytes)
+
+  const preview = encoded.encoding === "utf8"
+    ? encoded.bytes.toString("utf8", 0, Math.min(encoded.bytes.length, 600))
+    : null
+
+  const metadata = {
+    schemaVersion: STORE_VERSION,
+    ref: evidenceReference(hash),
+    sha256: hash,
+    bytes: encoded.bytes.length,
+    encoding: encoded.encoding,
+    mediaType: encoded.mediaType,
+    kind: options.kind || existing?.kind || "tool-output",
+    source: options.source || existing?.source || null,
+    summary: options.summary || existing?.summary || null,
+    createdAt: existing?.createdAt || now,
+    lastSeenAt: now,
+    preview,
+  }
+  await writeFile(target.meta, JSON.stringify(metadata, null, 2) + "\n", "utf8")
+  return metadata
+}
+
+export async function getEvidence(root, ref, options = {}) {
+  const hash = normalizeHash(ref)
+  const target = evidencePaths(root, hash)
+  const metadata = JSON.parse(await readFile(target.meta, "utf8"))
+  const bytes = await readFile(target.data)
+  const start = Math.max(0, Number(options.start || 0))
+  const maxBytes = Math.max(1, Number(options.maxBytes || options.maxChars || 24_000))
+  const slice = bytes.subarray(start, Math.min(bytes.length, start + maxBytes))
+  return {
+    ...metadata,
+    truncated: start + slice.length < bytes.length,
+    start,
+    returnedBytes: slice.length,
+    content: metadata.encoding === "utf8" ? slice.toString("utf8") : slice.toString("base64"),
+  }
+}
+
+async function metadataFiles(root) {
+  const base = evidenceStoreRoot(root)
+  const prefixes = await readdir(base, { withFileTypes: true }).catch(() => [])
+  const files = []
+  for (const prefix of prefixes) {
+    if (!prefix.isDirectory()) continue
+    const dir = path.join(base, prefix.name)
+    for (const entry of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+      if (entry.isFile() && entry.name.endsWith(".json")) files.push(path.join(dir, entry.name))
+    }
+  }
+  return files
+}
+
+export async function evidenceStoreStatus(root = process.cwd()) {
+  const files = await metadataFiles(root)
+  let bytes = 0
+  let oldest = null
+  let newest = null
+  for (const file of files) {
+    const meta = JSON.parse(await readFile(file, "utf8").catch(() => "{}"))
+    bytes += Number(meta.bytes || 0)
+    if (meta.createdAt && (!oldest || meta.createdAt < oldest)) oldest = meta.createdAt
+    if (meta.lastSeenAt && (!newest || meta.lastSeenAt > newest)) newest = meta.lastSeenAt
+  }
+  return {
+    schemaVersion: STORE_VERSION,
+    root: evidenceStoreRoot(root),
+    entries: files.length,
+    bytes,
+    oldest,
+    newest,
+  }
+}
+
+export async function gcEvidenceStore(root = process.cwd(), options = {}) {
+  const files = await metadataFiles(root)
+  const maxEntries = Math.max(10, Number(options.maxEntries || 2_000))
+  const maxAgeMs = Math.max(0, Number(options.maxAgeDays ?? 30)) * 86_400_000
+  const now = Date.now()
+  const rows = []
+  for (const metaFile of files) {
+    const meta = JSON.parse(await readFile(metaFile, "utf8").catch(() => "{}"))
+    const time = Date.parse(meta.lastSeenAt || meta.createdAt || 0) || 0
+    rows.push({ metaFile, meta, time })
+  }
+  rows.sort((a, b) => b.time - a.time)
+
+  const removed = []
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index]
+    const tooMany = index >= maxEntries
+    const tooOld = maxAgeMs > 0 && row.time > 0 && now - row.time > maxAgeMs
+    if (!tooMany && !tooOld) continue
+    const hash = row.meta.sha256 || path.basename(row.metaFile, ".json")
+    const target = evidencePaths(root, hash)
+    await rm(target.meta, { force: true })
+    await rm(target.data, { force: true })
+    removed.push(evidenceReference(hash))
+  }
+
+  return {
+    removed,
+    removedCount: removed.length,
+    status: await evidenceStoreStatus(root),
+  }
+}
+
+export async function evidenceExists(root, ref) {
+  try {
+    const target = evidencePaths(root, normalizeHash(ref))
+    const info = await stat(target.data)
+    return info.isFile()
+  } catch {
+    return false
+  }
+}

package/lib/hermes-bridge.mjs

@@ -1,11 +1,20 @@
 import { spawnSync } from "node:child_process"
+import { resolveWindowsCommand } from "./windows-shim.mjs"
+
+function runHermesVersion() {
+  if (process.platform !== "win32") return spawnSync("hermes", ["--version"], { encoding: "utf8" })
+  const resolved = resolveWindowsCommand("hermes")
+  if (!resolved) return { status: 127, stdout: "", stderr: "Hermes CLI not found" }
+  return spawnSync(resolved.executable, [...resolved.argsPrefix, "--version"], { encoding: "utf8" })
+}
 
 export function hermesStatus() {
-  const result = spawnSync("hermes", ["--version"], { encoding: "utf8", shell: process.platform === "win32" })
+  const result = runHermesVersion()
   return {
     available: result.status === 0,
     version: result.status === 0 ? String(result.stdout || result.stderr || "").trim() : null,
     error: result.status === 0 ? null : String(result.stderr || result.stdout || "Hermes CLI not found").trim(),
+    mode: "optional-sidecar",
   }
 }
 
@@ -15,11 +24,46 @@ export function buildHermesDelegationPrompt(contextPack) {
     "Implement exactly the approved task described below.",
     "Do not broaden scope, merge, push, publish, deploy, or alter durable UES state.",
     "Run the declared verification and return a concise structured report.",
+    "Large evidence is referenced by evidence:sha256 pointers; fetch only the slice required for the task.",
+    "",
+    JSON.stringify(contextPack, null, 2),
+  ].join("\n")
+}
+
+export function buildHermesWorkflowPrompt(contextPack, schedule) {
+  return [
+    "You are the optional Hermes sidecar for a UES V11 dynamic workflow.",
+    "Follow the supplied bounded wave schedule. Deterministic tasks are not delegated to LLM children.",
+    "Never exceed declared task ownership or concurrency. Persist outputs/evidence to files instead of conversational summaries.",
+    "Do not merge, push, publish, deploy, or mutate durable UES state except through explicitly supplied UES commands.",
+    "",
+    "SCHEDULE:",
+    JSON.stringify(schedule, null, 2),
     "",
+    "CONTEXT:",
     JSON.stringify(contextPack, null, 2),
   ].join("\n")
 }
 
+export function hermesSidecarPlan(input = {}) {
+  return {
+    schemaVersion: 2,
+    adapter: "hermes",
+    optional: true,
+    mode: input.mode || "one-shot",
+    maxConcurrent: Math.max(1, Math.min(16, Number(input.maxConcurrent || 4))),
+    durableStateOwner: "ues",
+    evidenceTransport: "content-addressed-pointers",
+    allowNestedDelegation: input.allowNestedDelegation === true,
+    safety: {
+      merge: false,
+      push: false,
+      publish: false,
+      deploy: false,
+      destructiveGit: false,
+    },
+  }
+}
 
 export function hermesOneShotArgs(prompt) {
   const text = String(prompt || "").trim()

package/lib/model-config.mjs

@@ -2,6 +2,8 @@ import { existsSync } from "node:fs"
 import { mkdir, readFile, writeFile } from "node:fs/promises"
 import path from "node:path"
 import { defaultModelPolicy, resolveModel } from "./model-policy.mjs"
+import { normalizeCapabilityProfile } from "./capability-registry.mjs"
+import { normalizePerformanceHistory, recordPerformanceOutcome } from "./model-performance.mjs"
 
 const TIERS = new Set(["light", "standard", "heavy"])
 
@@ -23,14 +25,24 @@ function normalize(policy) {
     if (TIERS.has(tier)) roleTiers[role] = tier
   }
 
+  const capabilities = {}
+  for (const [model, profile] of Object.entries(input.capabilities || {})) {
+    if (validModelID(model)) capabilities[model] = normalizeCapabilityProfile(profile)
+  }
+
+  const performance = normalizePerformanceHistory(input.performance || {})
+
   return {
-    schemaVersion: 1,
+    schemaVersion: 3,
     enabled: input.enabled === true,
     maxEscalations: Number.isInteger(input.maxEscalations)
       ? Math.max(0, Math.min(input.maxEscalations, 2))
       : base.maxEscalations,
     tiers,
     roleTiers,
+    capabilities,
+    performance,
+    performanceMinSamples: Number.isInteger(input.performanceMinSamples) ? Math.max(1, Math.min(input.performanceMinSamples, 20)) : base.performanceMinSamples,
   }
 }
 
@@ -56,6 +68,8 @@ export async function writeModelPolicy(configDir, patch = {}) {
     ...patch,
     tiers: { ...current.tiers, ...(patch.tiers || {}) },
     roleTiers: { ...current.roleTiers, ...(patch.roleTiers || {}) },
+    capabilities: { ...(current.capabilities || {}), ...(patch.capabilities || {}) },
+    performance: patch.performance || current.performance || {},
   })
   const file = modelPolicyFile(configDir)
   await mkdir(path.dirname(file), { recursive: true })
@@ -86,3 +100,9 @@ export function applyConfiguredModel(source, role, policy) {
   }
   return lines.join("\n")
 }
+
+export async function recordModelPerformance(configDir, outcome = {}) {
+  const current = await readModelPolicy(configDir)
+  const performance = recordPerformanceOutcome(current.performance || {}, outcome)
+  return writeModelPolicy(configDir, { performance })
+}

package/lib/model-performance.mjs

@@ -0,0 +1,113 @@
+export const MODEL_TASK_CLASSES = Object.freeze([
+  "general", "repo-scale", "debugging", "architecture", "security",
+  "migration", "frontend", "backend", "visual", "browser",
+])
+const KNOWN_TASK_CLASSES = new Set(MODEL_TASK_CLASSES)
+
+function boundedNumber(value, fallback = 0, min = 0, max = Number.MAX_SAFE_INTEGER) {
+  const number = Number(value)
+  if (!Number.isFinite(number)) return fallback
+  return Math.max(min, Math.min(max, number))
+}
+
+export function inferTaskClass(text = "", facts = {}) {
+  const explicit = String(facts.taskClass || "").trim().toLowerCase()
+  if (KNOWN_TASK_CLASSES.has(explicit)) return explicit
+  const value = String(text || "").toLowerCase()
+  if (/(whole repo|entire project|large monorepo|repo[- ]scale|cross[- ]module|toàn bộ dự án|nhiều module)/.test(value)) return "repo-scale"
+  if (/(prompt injection|security|auth|authorization|permission|secret|credential|bảo mật|phân quyền)/.test(value)) return "security"
+  if (/(migration|schema|database|sql|backfill|migrate)/.test(value)) return "migration"
+  if (/(screenshot|visual|figma|pixel|responsive|storybook)/.test(value)) return "visual"
+  if (/(browser|playwright|e2e|web page|click flow)/.test(value)) return "browser"
+  if (/(root cause|debug|regression|crash|failing|bug|lỗi)/.test(value)) return "debugging"
+  if (/(architecture|architect|design decision|system design|kiến trúc)/.test(value)) return "architecture"
+  if (/(react|next\.js|vue|svelte|css|frontend|ui\b)/.test(value)) return "frontend"
+  if (/(api|service|node|python|java|dotnet|backend|server)/.test(value)) return "backend"
+  return "general"
+}
+
+export function normalizePerformanceRecord(record = {}) {
+  record = record && typeof record === "object" ? record : {}
+  const samples = Math.floor(boundedNumber(record.samples, 0, 0))
+  const successes = Math.floor(boundedNumber(record.successes, Math.round(samples * boundedNumber(record.passRate, 0, 0, 1)), 0, samples))
+  return {
+    samples,
+    successes,
+    passRate: samples ? successes / samples : 0,
+    avgRetries: boundedNumber(record.avgRetries, 0, 0, 100),
+    avgTokens: boundedNumber(record.avgTokens, 0, 0),
+    avgLatencyMs: boundedNumber(record.avgLatencyMs, 0, 0),
+    updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : null,
+  }
+}
+
+export function normalizePerformanceHistory(history = {}) {
+  const output = {}
+  for (const [model, classes] of Object.entries(history || {})) {
+    if (!model || !classes || typeof classes !== "object") continue
+    const normalizedClasses = {}
+    for (const [taskClass, record] of Object.entries(classes)) {
+      if (!KNOWN_TASK_CLASSES.has(taskClass) && taskClass !== "overall") continue
+      normalizedClasses[taskClass] = normalizePerformanceRecord(record)
+    }
+    if (Object.keys(normalizedClasses).length) output[model] = normalizedClasses
+  }
+  return output
+}
+
+function mergeAverage(previousAverage, previousSamples, value) {
+  return previousSamples <= 0 ? value : ((previousAverage * previousSamples) + value) / (previousSamples + 1)
+}
+
+export function recordPerformanceOutcome(history = {}, outcome = {}) {
+  const model = String(outcome.model || "").trim()
+  if (!model) throw new Error("model performance outcome requires model")
+  const taskClass = inferTaskClass(outcome.text || "", { taskClass: outcome.taskClass })
+  const normalized = normalizePerformanceHistory(history)
+  const current = normalizePerformanceRecord(normalized[model]?.[taskClass] || {})
+  const samples = current.samples
+  const passed = outcome.passed === true
+  const next = {
+    samples: samples + 1,
+    successes: current.successes + (passed ? 1 : 0),
+    passRate: 0,
+    avgRetries: mergeAverage(current.avgRetries, samples, boundedNumber(outcome.retries, 0, 0, 100)),
+    avgTokens: mergeAverage(current.avgTokens, samples, boundedNumber(outcome.tokens, 0, 0)),
+    avgLatencyMs: mergeAverage(current.avgLatencyMs, samples, boundedNumber(outcome.latencyMs, 0, 0)),
+    updatedAt: new Date().toISOString(),
+  }
+  next.passRate = next.successes / next.samples
+  return { ...normalized, [model]: { ...(normalized[model] || {}), [taskClass]: next } }
+}
+
+function performanceAdjustment(record, minSamples) {
+  const normalized = normalizePerformanceRecord(record)
+  if (normalized.samples <= 0) return { adjustment: 0, confidence: 0, record: normalized }
+  const confidence = Math.min(1, normalized.samples / Math.max(1, minSamples))
+  if (normalized.samples < minSamples) return { adjustment: 0, confidence, record: normalized }
+  const correctness = (normalized.passRate - 0.5) * 80
+  const retryPenalty = Math.min(20, normalized.avgRetries * 5)
+  const latencyPenalty = normalized.avgLatencyMs > 0 ? Math.min(10, Math.max(0, Math.log10(Math.max(1, normalized.avgLatencyMs / 1000)) * 3)) : 0
+  return { adjustment: (correctness - retryPenalty - latencyPenalty) * confidence, confidence, record: normalized }
+}
+
+export function rerankCapabilitySelection(selection = {}, history = {}, options = {}) {
+  const taskClass = inferTaskClass(options.text || "", { taskClass: options.taskClass })
+  const minSamples = Math.max(1, Number(options.minSamples || 3))
+  const normalized = normalizePerformanceHistory(history)
+  const candidates = (selection.candidates || []).map((candidate) => {
+    const record = normalized[candidate.id]?.[taskClass] || normalized[candidate.id]?.overall || null
+    const evidence = performanceAdjustment(record, minSamples)
+    return {
+      ...candidate,
+      baseScore: Number(candidate.score || 0),
+      empiricalTaskClass: taskClass,
+      empiricalEvidence: evidence.record,
+      empiricalConfidence: Number(evidence.confidence.toFixed(4)),
+      adjustedScore: Number((Number(candidate.score || 0) + evidence.adjustment).toFixed(6)),
+    }
+  })
+  const eligible = candidates.filter((candidate) => candidate.eligible)
+    .sort((a, b) => b.adjustedScore - a.adjustedScore || b.baseScore - a.baseScore)
+  return { ...selection, selected: eligible[0] || null, candidates, taskClass, empirical: true }
+}